Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Study Prep MCP Server Get an overview of my study documents"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP tools to browse and prepare study materials from a local document folder — PDF, Markdown, plain text, and Word files.
The server extracts text and structure locally; your MCP client (e.g. Cursor) generates summaries and practice questions from the returned content.
Tool | What it does |
| Categories, file counts, sizes, supported extensions |
| List files with optional category or glob filter |
| Read or extract text from one file (PDF page range supported) |
| Full-text search with snippet context |
| Keyword extraction via YAKE (one doc or whole category) |
| Headings / outline for structured review |
| Split long docs into numbered study chunks |
| Bundle excerpts, key terms, and AI prompts for a topic |
| Labeled excerpts + instructions for Q&A generation |
Related MCP server: Mind Forge
git clone https://github.com/YOUR_ORG/study-md-mcp.git
cd study-md-mcp
python3 -m venv .venv
source .venv/bin/activate
pip install -e .
# Smoke test on stdio (Ctrl+C to stop)
MD_DOCS_PATH=/path/to/your/study-documents python server.pyOr with uv:
git clone https://github.com/YOUR_ORG/study-md-mcp.git
cd study-md-mcp
uv venv && uv pip install -e .
MD_DOCS_PATH=/path/to/your/study-documents uv run server.pyVariable | Default | Purpose |
|
| FastMCP server name |
|
| Root folder for study documents |
Set MD_DOCS_PATH to the folder containing your study files. On WSL with Windows files, use the /mnt/c/... path.
Copy examples/cursor-mcp-config.json and adjust paths:
{
"mcpServers": {
"study-md": {
"command": "/path/to/study-md-mcp/.venv/bin/python",
"args": ["/path/to/study-md-mcp/server.py"],
"env": {
"MD_MCP_NAME": "study-md",
"MD_DOCS_PATH": "/path/to/your/study-documents"
}
}
}
}Then ask Cursor to use study-md tools, e.g. “Search my study docs for essay requirements” or “Prepare a study session on offer terms.”
If Claude Desktop runs on Windows but documents live in WSL, see examples/claude-desktop-config.json.
claude mcp add study-md \
-e MD_MCP_NAME=study-md \
-e MD_DOCS_PATH=/path/to/your/study-documents \
-- /path/to/study-md-mcp/.venv/bin/python /path/to/study-md-mcp/server.pyExtension | Method |
| Direct UTF-8 read |
| Text extraction via PyMuPDF |
| Paragraph text via python-docx |
Scanned/image-only PDFs are not supported (no OCR).
Organize files under MD_DOCS_PATH by category subfolder:
study-documents/
├── notes/
├── exams/
├── essays/
└── reference/Empty category folders appear in get_corpus_overview with count 0.
MIT — see LICENSE.
Extract keywords from one document or an entire category using YAKE.
Args:
relative_path: Optional single file path relative to docs root
category: Optional category folder when relative_path is not set
top_n: Number of terms to return (default 20)
| Name | Required | Description | Default |
|---|---|---|---|
| relative_path | No | ||
| category | No | ||
| top_n | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full behavioral disclosure burden. It mentions using YAKE algorithm but does not disclose whether the tool is read-only, modifies data, or has any side effects. Basic behavioral traits are missing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, consisting of a main sentence and an Args section. It is front-loaded with the primary action. Could be slightly more concise by omitting 'using YAKE' if unnecessary, but overall efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that an output schema exists (though not shown), the description does not need to explain return values. However, it lacks contextual details about document sources, prerequisites, and how the tool selects between file and category. Adequate but not fully comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description adds value by explaining each parameter's meaning: relative_path is a single file path, category is a category folder, top_n is number of terms. However, it does not clarify the mutual exclusivity of relative_path and category or define what constitutes a valid 'category'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Extract keywords from one document or an entire category,' clearly indicating the verb (extract) and resource (keywords from document/category). This distinguishes it from sibling tools like read_document or search_documents, but does not specify what 'category' refers to exactly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains parameter usage: relative_path for a single file, category when relative_path is not set, and top_n for number of terms. However, it does not provide guidance on when to use this tool over alternatives, such as when keyword extraction is preferred over reading the full document.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return categories, file counts, total size, and supported extensions in the corpus.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. While it implies a read-only operation by saying 'return', it does not disclose any behavioral traits such as performance implications, authentication needs, or whether the data is aggregated. This leaves gaps for an AI agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with 12 words, straight to the point. It front-loads the purpose and contains no extraneous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters and no annotations, the description covers the return values adequately for a simple overview. It could mention that it covers the entire corpus, but the context (no filtering) implies that. Overall sufficient for the complexity level.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so schema coverage is 100%. The description adds no parameter info, but none is needed. A baseline score of 4 is appropriate for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns specific corpus metrics: categories, file counts, total size, and supported extensions. It distinguishes itself from sibling tools like list_documents (which lists documents) and get_document_outline (which focuses on an individual document).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. The context implies it's for getting a high-level overview of the entire corpus, but lacks when-not-to-use or specific scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return document outline from markdown headings or heading-like lines.
Args:
relative_path: Path relative to docs root
| Name | Required | Description | Default |
|---|---|---|---|
| relative_path | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Mentions handling 'heading-like lines' but omits error handling, limitations (e.g., non-markdown files), and whether it is read-only. Without annotations, more behavioral context would be helpful.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. Front-loaded with the verb 'Return' and immediately explains what it does.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a simple tool with output schema, but lacks details about input validation, file type support, and potential errors. No mention of how outline is structured.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Single parameter 'relative_path' is described as 'Path relative to docs root', adding meaning beyond the schema's 'Relative Path' title. Clarifies the path base, which is useful.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it returns document outline from markdown headings, distinguishing it from sibling tools like read_document (full content) and search_documents (search).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs. alternatives like read_document or list_documents. No context on prerequisites or when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return labeled excerpts and instructions for generating practice Q&A.
Args:
relative_path: Optional single file path relative to docs root
topic: Optional search topic when relative_path is not set
num_excerpts: Number of excerpts to include (default 5)
| Name | Required | Description | Default |
|---|---|---|---|
| relative_path | No | ||
| topic | No | ||
| num_excerpts | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It does not mention side effects, required permissions, rate limits, or whether the operation is read-only. The description only states the output, lacking transparency beyond basic function.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise: one sentence for purpose followed by parameter explanations. No extraneous text, and the key information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema exists and the tool has only three optional parameters, the description adequately covers the tool's purpose and parameter usage. However, it lacks usage guidance and some behavioral details, but remains generally complete for a straightforward retrieval tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description adds some meaning: it explains 'relative_path' is an optional single file path, 'topic' is a search topic used when relative_path is not set, and 'num_excerpts' is the count. This adds value beyond the schema's titles and defaults, though more detail could be provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Return labeled excerpts and instructions for generating practice Q&A,' which specifies the verb (return) and the resource (labeled excerpts and instructions). This distinguishes it from sibling tools like 'extract_key_terms' or 'get_study_chunks'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as 'get_study_chunks' or 'search_documents'. The description does not include any contextual cues or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Split a document into numbered study-sized chunks.
Args:
relative_path: Path relative to docs root
chunk_chars: Target chunk size in characters (default 3000)
overlap: Overlap between consecutive chunks (default 200)
| Name | Required | Description | Default |
|---|---|---|---|
| relative_path | Yes | ||
| chunk_chars | No | ||
| overlap | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It states the tool 'split[s] a document into numbered study-sized chunks' and lists default parameters, but omits behavioral traits like whether the document is read-only or if any side effects occur.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: one sentence for purpose followed by a compact list of arguments. Every sentence adds value with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that the output schema exists and the parameter count is low (3), the description covers all necessary details: what the tool does, what each parameter means, and defaults. No missing context for a chunking tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate. It describes all three parameters: 'relative_path' as path relative to docs root, 'chunk_chars' as target chunk size with default 3000, and 'overlap' as overlap with default 200. This adds meaning beyond the raw schema, though it could be more concise.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the action ('Split a document') and the resource ('numbered study-sized chunks'). This clearly distinguishes it from siblings like 'read_document' or 'get_document_outline'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for studying a document in pieces but does not explicitly state when to use it instead of alternatives like 'read_document' or 'get_quiz_source_material'. No exclusions or when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List study documents with relative path, size, and type.
Args:
category: Optional subfolder name (e.g. lpdp, uwa, learn)
pattern: Optional glob matched against relative path (e.g. *.pdf, lpdp/*)
| Name | Required | Description | Default |
|---|---|---|---|
| category | No | ||
| pattern | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavior. It states the tool returns metadata (path, size, type) and supports optional filtering. However, it does not clarify scope (all documents? recursive? hidden files?) or whether it is read-only. It adds moderate value but lacks full transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: two sentences for purpose, then parameter details. No extraneous text. The purpose is front-loaded, followed by structured argument descriptions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has only 2 optional parameters and an output schema, the description is mostly complete. It explains what the tool does and what each parameter does. However, it could mention if listing is limited to certain scopes (e.g., current directory only) or if there are any limits (e.g., max items).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description compensates well. It explains 'category' as an optional subfolder name and 'pattern' as a glob matched against relative path, with examples (e.g., *.pdf). This adds meaning beyond the schema's parameter names and defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists study documents with relative path, size, and type. The verb 'list' and resource 'study documents' are specific. It distinguishes from siblings like search_documents (which searches content) and read_document (which retrieves content).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like search_documents or get_corpus_overview. The description only explains parameters but does not indicate prerequisites or contexts (e.g., before reading, or for browsing).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Bundle excerpts, key terms, and suggested AI prompts for a study topic.
Args:
topic: Study topic or search query
categories: Comma-separated category folders to search (empty = all)
paths: Comma-separated relative file paths to include directly
max_chars: Maximum total characters in the bundle (default 12000)
| Name | Required | Description | Default |
|---|---|---|---|
| topic | Yes | ||
| categories | No | ||
| paths | No | ||
| max_chars | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It does not mention whether the tool is read-only, destructive, requires authentication, or any side effects. The only behavioral clue is the bundling action, but no safety or operation details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with a one-sentence purpose followed by a clear parameter list. It is front-loaded but could be more structured (e.g., bullet points for parameters).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the purpose and parameters adequately but does not explain the output format, despite an output schema existing. Given the presence of the output schema, this gap is acceptable but not ideal.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema coverage, the description adds significant meaning: it explains each parameter's role (e.g., 'Comma-separated category folders to search', 'Maximum total characters'). This compensates for the bare schema titles.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action: 'Bundle excerpts, key terms, and suggested AI prompts for a study topic.' It specifies the resource (study topic) and the verb (bundle), and the combination distinguishes it from siblings like extract_key_terms or get_study_chunks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like get_study_chunks or search_documents. No when-not or context for selection is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read or extract text from a study document.
Args:
relative_path: Path relative to docs root, e.g. lpdp/essay.pdf
max_chars: Maximum characters to return (default 50000)
page_start: PDF only — 1-based start page (0 = from beginning)
page_end: PDF only — 1-based end page inclusive (0 = through last page)
| Name | Required | Description | Default |
|---|---|---|---|
| relative_path | Yes | ||
| max_chars | No | ||
| page_start | No | ||
| page_end | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so description carries the burden. It partially discloses behavior (PDF-only page params, default max_chars) but omits details like error handling, auth requirements, or support for non-PDF formats.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently front-loaded with purpose, followed by a clear, compact argument list. Every sentence adds value with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema, return values are not needed. The description covers parameters well and notes PDF-specific behavior. However, it could explicitly state supported file formats; the PDF-only qualifiers on page params imply non-PDF support but are ambiguous.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so description must compensate. It thoroughly explains each parameter: relative_path with example path, max_chars with default, page_start/page_end as PDF-only with 1-based indexing and clarifying zero values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with 'Read or extract text from a study document,' providing a specific verb and resource. It clearly distinguishes from sibling tools like list_documents (listing) or search_documents (searching).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidelines on when to use this tool versus alternatives (e.g., get_document_outline for structure, search_documents for queries). Usage is implied via the purpose but lacks exclusions or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search document text with snippet context around each match.
Args:
query: Case-insensitive search string
category: Optional subfolder filter
max_results: Maximum number of matching files (default 10)
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| category | No | ||
| max_results | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full responsibility for behavioral disclosure. It reveals case-insensitive search and snippet context, but lacks details on rate limits, auth requirements, or error handling. It is adequately transparent for a read-like operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with one brief summary line and a structured Args list. Every sentence provides value without repetition or unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers key behaviors (search, snippet context, filtering, result limit) and is sufficient given the presence of an output schema for return values. It could mention pagination or empty results, but is largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds rich semantic meaning to all three parameters beyond the schema: 'query' is case-insensitive, 'category' is a subfolder filter, 'max_results' sets a limit with default. Schema coverage was 0%, so this fully compensates.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Search document text with snippet context around each match,' specifying the verb (search) and resource (document text). This distinguishes it from siblings like 'list_documents' or 'read_document' which do not perform text search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, no when-not-to-use conditions, and no mention of exclusions or prerequisites. It only describes basic behavior without contextual usage advice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0extract_key_termsget_corpus_overviewget_document_outlineget_quiz_source_materialget_study_chunkslist_documentsprepare_study_sessionread_documentsearch_documentsEach tool targets a unique aspect of study preparation, such as document overview, reading, chunking, keyword extraction, quiz generation, and session bundling. There is no overlap in functionality, making it easy for an agent to select the correct tool.
All tool names follow a consistent verb_noun pattern with snake_case, e.g., 'extract_key_terms', 'get_document_outline', 'list_documents'. The naming is predictable and clear throughout.
With 9 tools, the set is well-scoped for study preparation. Each tool serves a distinct purpose without redundancy, covering corpus management, document processing, and content generation.
The tool set covers all common study needs: browsing documents, reading with pagination, extracting outlines, chunking, keyword extraction, quiz material generation, and full session preparation. There are no obvious missing operations like adding or deleting documents, but the server appears to be a read-only study aid, so this is appropriate.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Search and reason over your Obsidian-style Markdown vault, right from ChatGPT.
Voice-led, FSRS-scheduled flashcards from YouTube, PDFs, web, or text. Auto-graded quizzes.
Parse, extract, split, and ask over digital PDFs (text layer, no OCR) from Cursor and Claude.
Your private knowledge base: upload documents (.md, .txt, .docx, PDF, images), the platform indexes
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/tyorus/mcp-study-prep'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
