crepe-mcp
This server lets you create, edit, compile, inspect, and export presentations, plus run academic, Wikipedia, and web research.
Create and manage in-memory slide decks with metadata, slide insertion/replacement/deletion, and listing/cleanup.
Import/export Pandoc Markdown slide sources and inspect individual slides or deck state.
Compile decks to Beamer PDF or PowerPoint PPTX, then render compiled slides as PNGs for visual validation.
Search Semantic Scholar for academic papers and retrieve titles, links, and abstracts.
Search the web via Tavily and extract readable text from webpages.
Search Wikipedia and fetch full article text for reference material.
Provides academic paper search capabilities via Semantic Scholar API, allowing users to find and cite scholarly articles.
Provides tools for searching and reading Wikipedia articles, enabling access to encyclopedia content for research and presentation creation.
Click on "Deploy 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., "@crepe-mcp Create a 5-slide presentation about machine learning basics"
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.
CREPE — Compile, Research, Export, Presentation Engine
CREPE is a specialized Model Context Protocol (MCP) server designed primarily for Goose (and fully compatible with other MCP-compliant agents such as Claude Desktop, Antigravity / AGY CLI, and Cursor). It equips AI agents with the tools to draft academic slide decks in Pandoc Markdown, compile publication-grade Beamer PDFs or PowerPoint decks, author multi-chapter A4 research reports, format multi-sheet Excel workbooks, validate and export Draw.io architecture diagrams, and conduct academic literature searches across Semantic Scholar, arXiv, Wikipedia, and the live web.
How It Works
CREPE sits between your AI agent and your system's underlying compilation, rendering, and research tools, exposing stateful in-memory builder engines through standard MCP protocols:
flowchart TD
subgraph ClientLayer["AI Agent Host"]
Agent["Goose / AI Agent (MCP Client)"]
end
subgraph FastMCPLayer["CREPE Modular FastMCP 3.X Layer"]
Pres["crepe-presentations<br/>(15 tools)"]
Docs["crepe-documents<br/>(12 tools)"]
Research["crepe-research<br/>(7 tools)"]
Sheets["crepe-spreadsheets<br/>(4 tools)"]
Diagrams["crepe-diagrams<br/>(3 tools)"]
end
subgraph SystemTools["System CLI Engines"]
Pandoc["Pandoc + LuaLaTeX<br/>(PDF, PPTX, DOCX)"]
LibreOffice["LibreOffice + PyMuPDF<br/>(PNG Slide Rasterization)"]
Chromium["Headless Chromium<br/>(Dynamic Web Scraping)"]
DrawioCLI["draw.io Desktop<br/>(Vector/PNG Export)"]
end
subgraph ExternalAPIs["External Research & Web APIs"]
SemScholar["Semantic Scholar API<br/>(Literature & Citations)"]
ArxivAPI["arXiv API<br/>(Preprints)"]
TavilyAPI["Tavily Search API<br/>(Live Web Search)"]
WikiAPI["Wikipedia REST API<br/>(Encyclopedic Knowledge)"]
end
subgraph PythonEngines["Internal Python Engines & Linters"]
OpenPyXL["openpyxl Engine<br/>(Formatted Spreadsheets)"]
Linters["In-Memory Linters<br/>(AST & Syntax Validation)"]
end
%% Client connections
Agent --> Pres
Agent --> Docs
Agent --> Research
Agent --> Sheets
Agent --> Diagrams
%% Sub-server specific connections
Pres --> Linters
Pres --> Pandoc
Pres --> LibreOffice
Docs --> Linters
Docs --> Pandoc
Docs --> LibreOffice
Research --> SemScholar
Research --> ArxivAPI
Research --> TavilyAPI
Research --> WikiAPI
Research --> Chromium
Sheets --> OpenPyXL
Diagrams --> Linters
Diagrams --> DrawioCLI
%% Nord Theme High-Contrast Node Styling
classDef client fill:#5E81AC,stroke:#ECEFF4,stroke-width:2px,color:#ECEFF4;
classDef pres fill:#81A1C1,stroke:#2E3440,stroke-width:1.5px,color:#2E3440;
classDef docs fill:#88C0D0,stroke:#2E3440,stroke-width:1.5px,color:#2E3440;
classDef research fill:#8FBCBB,stroke:#2E3440,stroke-width:1.5px,color:#2E3440;
classDef sheets fill:#A3BE8C,stroke:#2E3440,stroke-width:1.5px,color:#2E3440;
classDef diagrams fill:#B48EAD,stroke:#2E3440,stroke-width:1.5px,color:#2E3440;
classDef engine fill:#81A1C1,stroke:#2E3440,stroke-width:1.5px,color:#2E3440;
classDef api fill:#A3BE8C,stroke:#2E3440,stroke-width:1.5px,color:#2E3440;
classDef internal fill:#EBCB8B,stroke:#2E3440,stroke-width:1.5px,color:#2E3440;
class Agent client;
class Pres pres;
class Docs docs;
class Research research;
class Sheets sheets;
class Diagrams diagrams;
class Pandoc,LibreOffice,Chromium,DrawioCLI engine;
class SemScholar,ArxivAPI,TavilyAPI,WikiAPI api;
class OpenPyXL,Linters internal;
%% Major Subgraph Containers (Distinct Nord Backgrounds & Bold Accent Borders)
style ClientLayer fill:#2E3440,stroke:#88C0D0,stroke-width:2px,color:#ECEFF4;
style FastMCPLayer fill:#242933,stroke:#81A1C1,stroke-width:2px,color:#ECEFF4;
style SystemTools fill:#2E3440,stroke:#5E81AC,stroke-width:2px,color:#ECEFF4;
style ExternalAPIs fill:#2E3440,stroke:#A3BE8C,stroke-width:2px,color:#ECEFF4;
style PythonEngines fill:#2E3440,stroke:#B48EAD,stroke-width:2px,color:#ECEFF4;
%% Link Styling (Bright Frost Cyan)
linkStyle default stroke:#88C0D0,stroke-width:1.6px;Related MCP server: agent-reader
FastMCP Architecture
Built natively on FastMCP (3.x and 4.x are both supported; the dependency is
pinned >=3.0,<5), CREPE provides high-reliability agentic pair-authoring:
Modular Context Efficiency: Six independent sub-servers allow agents to mount only the tools required for a specific task, keeping LLM context windows lean and focused.
Embedded Agent Instructions: Initialization prompts inject strict Pandoc Markdown rules, preventing LaTeX syntax hallucinations and formatting errors.
Deterministic Concurrency: FIFO ticket locks and
expected_slide_countguards prevent race conditions when agents spawn concurrent sub-agents to draft sections simultaneously.Live Inspectable Resources: Real-time URIs (
presentation://{id}/source,document://{id}/config) enable instant state inspection without tool-call overhead.Scaffolding Prompts: Standard prompt templates (
academic_presentation,technical_report,spreadsheet_model,drawio_diagram) bootstrap complex project structures.
Sub-Servers & Tools Overview (6 Servers, 48 Tools)
Sub-server | Command Entry Point | Tools | Primary Domain |
Presentations |
| 15 | Slide deck authoring, Beamer/PPTX compilation, PNG rendering |
Documents |
| 12 | A4 reports and papers, LaTeX/DOCX compilation, PNG rendering |
Research |
| 6 | Semantic Scholar, arXiv, Tavily web search, Wikipedia |
Spreadsheets |
| 4 | Styled Excel workbooks (.xlsx), Markdown table conversion |
Diagrams |
| 3 | Draw.io XML inspection, linting, and headless image export |
Reader |
| 8 | Deterministic reading of PDF, DOCX, ODT, EPUB, HTML, LaTeX, Markdown, PPTX, XLSX: outline, pages, search, tables, equations |
1. Presentations (crepe-presentations — 15 tools)
Stateful, incremental slide deck builder that compiles Pandoc Markdown into Beamer PDF presentations or PowerPoint files.
Deck Lifecycle:
create_presentation,duplicate_presentation,cleanup_presentation,list_presentations,get_presentation.Slide Manipulation:
set_slide(append or insert at index),get_slide,move_slide,delete_slide,update_presentation_metadata.Source Synchronization:
export_presentation_source,import_presentation_source(round-trip markdown editing).Compilation & Verification:
compile_presentation(Beamer PDF / PPTX),render_slides_as_pngs(high-DPI PNG verification),lint_presentation.
2. Documents (crepe-documents — 12 tools)
Hierarchical report and article authoring engine for structured academic documents.
Document Management:
create_document,get_document,list_documents,cleanup_document,update_document_metadata.Section Structuring:
set_chapter,set_section(nested subsection support),delete_chapter.Compilation & Output:
export_document_source,compile_document(LuaLaTeX PDF / DOCX),render_document_as_pngs,lint_document.
3. Research & Web Discovery (crepe-research — 7 tools)
Literature discovery and live web extraction with built-in rate limit handling.
Academic Papers:
academic_search(queries Semantic Scholar API with citation counts and rate-limit backoff),openalex_search(queries OpenAlex for venue, year, DOI and citation counts; works without a key),arxiv_search(queries arXiv API for recent preprints).Encyclopedic Knowledge:
wikipedia_search(finds relevant topics),wikipedia_read(extracts clean text body).Web Retrieval:
web_search(Tavily search integration),fetch_webpage(extracts clean markdown with headless Chromium fallback).
4. Spreadsheets (crepe-spreadsheets — 4 tools)
Programmatic workbook creation with styling, number formatting, and table transformation.
Workbook Builder:
create_excel(multi-sheet workbooks with column types, colors, and headers),update_excel_sheet(append rows or update cells).Inspection & Ingestion:
inspect_excel(reads sheets, dimensions, and previews),markdown_table_to_excel(converts markdown tables directly to styled.xlsx).
5. Diagrams (crepe-diagrams — 3 tools)
Inspection, deep linting, and export for .drawio diagram files.
Validation:
inspect_drawio(metadata and page structure),lint_drawio(validates cell hierarchy, decompresses XML, checks base IDs).Export:
export_drawio(headless rasterization to transparent high-DPI PNG, SVG, or PDF).
6. Reader (crepe-reader — 9 tools)
Reads existing documents without any model, so an agent can work on a long file in small pieces. A file is read once into a store of pages, sections, paragraphs and numbered items (cached under the system temp folder, CREPE_SCRATCH_BASE); each tool returns a piece of it. The first read of a long PDF takes seconds; pages with tables are analysed in worker processes, and later calls are instant.
Orientation:
open_document(title, parts of a PDF bundle, outline with pages, counts of figures, tables, equations).Reading:
read_pages(about 12,000 characters per call, with a continuation cursor),read_section(by outline heading, with a cursor for long sections),search_document.Numbered items:
list_assetsandget_assetreturn figures, tables (as Markdown), equations (text and TeX), algorithms, listings and references, with the sentences that cite them.Review marks:
list_changeslists the tracked insertions, deletions and comments of a DOCX (author, date, text, the text a comment is attached to, section); the other tools show its accepted view.Output:
render_page_image(a page of a PDF, DOCX, ODT, RTF or PPTX as a PNG or JPEG; Office files need LibreOffice) anddocument_to_markdown(the whole document as an editable.md).Formats: PDF through PyMuPDF (layout rules relative to each document's own type sizes); DOCX, ODT, RTF, EPUB, HTML, LaTeX, reStructuredText, Markdown, Org, Jupyter, PPTX, XLSX and CSV through pandoc's AST. Formats without pages are cut into logical pages of about 3,500 characters; a Markdown slide deck is read one frame per page, with TikZ blocks as
diagramitems, speaker notes on request (read_pages(notes=true)) and figure files resolved through the deck'sresource-path(attached byget_assetwhenimages.enabledis on).CREPE_READER_ROOTScan restrict the readable folders.
Setup & Configuration
CREPE includes an automated installer script (setup.py) that detects your system dependencies, registers extensions into Goose (and other agents), and configures environment variables.
Automated Setup
# Standard installation for Goose and detected agents
./setup.py --install
# Install specifically for Goose
./setup.py --install --target goose
# Enable all 6 sub-servers up front — REQUIRED for ACP providers such as
# claude-acp, gemini-cli, cursor-agent or codex, which cannot reach Goose's
# Extension Manager to switch a disabled sub-server on. See "Sub-server
# enablement" below.
./setup.py --install --target goose --enable-all
# Non-interactive installation with custom paths (API keys: see "API keys" below)
./setup.py --install -y \
--browser-path "/usr/bin/chromium"
# Uninstall CREPE from all agent configs and shell profiles
./setup.py --uninstallCLI Options & Configuration Flags
Flag | Argument | Default | Description |
| — | True | Register CREPE MCP servers with client configurations |
| — | False | Remove CREPE MCP servers and clean up profile entries |
|
|
| Specify which agent configurations to update |
| — | False | Goose only: register every sub-server as |
| — | False | Accept all defaults and flags without interactive prompts |
|
| auto | Absolute path to Chromium/Chrome binary for JS page rendering |
|
| auto | Path to LibreOffice binary for PPTX slide rasterization |
|
| auto | Path to draw.io desktop binary for diagram export |
Resilient install
Re-running setup.py --install is safe:
Only the CREPE blocks of
~/.config/goose/config.yamlare edited. Comments, key order and every other setting stay as they were. If the file has an unexpected layout the script verifies the edit and falls back to a full rewrite.A timestamped backup (
config.yaml.bak-YYYYMMDD-HHMMSS, newest 5 kept) is written first, and the new file is swapped in atomically.An extension you already enabled or disabled keeps that state, and existing
envsvalues (paths) are kept unless you pass a new value.The
crepeagent skill is copied to~/.agents/skills/crepe/(see below). It replaces the old~/.config/goose/CREPE_AGENTS.mdcopy, which is removed.If a step fails the script prints which one and exits non-zero instead of reporting success.
Agent skill
skills/crepe/SKILL.md is the agent usage guide, in the open Agent Skills format: a short router (which server for which task, tool order, hard rules) plus one reference file per domain with the Markdown syntax, parameters, lint output and troubleshooting that used to live in AGENTS.md. setup.py --install copies the skill folder (SKILL.md, references/, scripts/) to ~/.agents/skills/crepe/. Goose lists installed skills in the agent prompt, so the agent learns about CREPE even while its extensions are still disabled.
Sub-server enablement
setup.py --install registers all six sub-servers but leaves only
crepe-research enabled. The other five are written with enabled: false plus a
description naming their tools and trigger, which Goose's Extension Manager reads
to switch them on when a task needs them. That keeps ~88% of CREPE's tool schema
(~4.6k tokens) out of the context window at session start.
This gating does not work under ACP providers. With claude-acp, gemini-cli,
cursor-agent or codex, Goose is not the agent — it delegates the loop to an
external tool and forwards its extensions over ACP. Only type: mcp extensions
survive that hop; the Extension Manager is type: platform, so the agent never sees
manage_extensions and can never enable a disabled sub-server.
Measured on Goose 1.49.0 with an identical "build a deck" prompt:
Provider | Sub-servers | Outcome |
| 4 disabled | 9 fruitless tool searches, nothing produced |
| all enabled | 1 tool search, then the deck compiled |
native (e.g. a custom OpenAI-compatible provider) | 4 disabled | agent called |
So install with --enable-all whenever the active provider is ACP-based:
./setup.py --install --target goose --enable-allNothing is lost. ACP hosts defer MCP tool schemas behind their own tool-search and fetch them only on use, so the expensive part (~21 KB / ~5.2k tokens across the 48 tools) still stays out of context — the same saving, made by the host rather than by Goose. Keep the default gated layout only for native Goose providers, where Goose loads every enabled schema up front.
Environment Variables
Variable | Required For | Default / Auto-detection |
|
| Read from the |
|
| Optional, from the |
|
| Optional, from the |
| JavaScript-heavy | Auto-detected from Chromium / Chrome / Brave |
| PPTX to PNG rendering | Auto-detected ( |
| Headless diagram export | Auto-detected ( |
| Loading the API keys | Registered by setup: |
API keys live in .env at the repository root (gitignored, mode 600), never in the agent host configs: setup registers only CREPE_ENV_FILE, and every sub-server loads the file at startup. A variable already set in the environment wins over the file.
# ~/git/crepe-mcp/.env
CREPE_TAVILY_API_KEY=tvly-...
CREPE_SEMANTIC_SCHOLAR_API_KEY=...
CREPE_OPENALEX_API_KEY=...API keys
API keys are never written to client configs (Goose, Claude, AGY) or to the shell profile. Each server loads
them at start from the first existing file of: $CREPE_ENV_FILE, ~/.config/crepe-mcp/.env, ./.env.
Variables already present in the process environment win over the file. Start from .env.example
and keep the file private (chmod 600; the servers warn otherwise). ./setup.py --install stores a key there for you,
taken from the environment or a hidden prompt, and never prints it. The repository carries a pre-commit and CI check
that fails on a key-like literal.
System Requirements
Python:
>=3.12macOS (Homebrew):
brew install python pandocandbrew install --cask mactex-no-gui libreoffice drawio font-noto-sans brave-browserPandoc:
>=3.0(required for markdown compilation to PDF, PPTX, DOCX)LuaLaTeX / TeX Live:
texlive-fullor MacTeX (required for PDF compilation)LibreOffice: (Optional / recommended) For rasterizing PPTX slides to PNG sequences
Draw.io Desktop: (Optional / recommended) For headless
.drawiodiagram export
Development
The servers run from venv/bin/crepe-*, so ./venv is what the agents actually execute.
python3 -m venv venv
venv/bin/pip install --upgrade . --group test # package + coverage (pip >= 25.1)
PYTHONPATH=src venv/bin/python -m unittest discover -s tests
pre-commit install # hooks mirror CIruff (
ruff check .andruff format --check .), basedpyright, vulture and pre-commit run from the system install; CI pins the same versions as.github/workflows/main.yml. Runruff format .before committing.The sdist carries
setup.pyandskills/, so an unpacked sdist installs the servers and the skill like a clone; the wheel holds only the Python package and thecrepe-*commands.The pre-commit hook
venv matches CIreinstalls the package into./venv(non-editable) before the checks, so the servers always run the code that passed them. Coverage has a floor that only goes up.skills/crepe/is the agent skill (Agent Skills format);./setup.py --installcopies it to~/.agents/skills/crepe/and--uninstallremoves it.tests/agent_prompts/holds smoke-test prompts for it. The repo's.agents/folder is local agent state (plans, local MCP configs) and is git-ignored.
Documentation & References
Online API Reference: Complete auto-generated documentation built via
pdoc.Agent skill: Syntax rules, tool order and troubleshooting for AI agents using CREPE tools.
Citation Metadata (CITATION.cff): Citation instructions for academic research using CREPE.
Release notes
0.5.0
openalex_searchincrepe-research(7 tools): OpenAlex works with venue, year, DOI, citation count and abstract; no key needed (the free daily budget is shared per IP address), optionalCREPE_OPENALEX_API_KEYgives its own budget.file://URLs increpe-reader: afile://URL is a validpath; web URLs are refused with a hint (download first, or usefetch_webpagefor HTML).Clearer routing for agents: the skill sends local files and PDFs to
crepe-readerfirst;fetch_webpageerrors onfile://and bare paths nameopen_document.
0.4.1
Legacy Office files checked against a real LibreOffice:
.doc,.xlsand.pptread through the flatpak install as well as a native one (absolute paths only); a test converts and reads real files when pandoc and LibreOffice are present. No change for users of 0.4.0.pymupdfis capped below 2.0: PyMuPDF 2.0 (released after 0.3.1) locates fewer tables in the PDF reader (captioninstead ofcaption+table), which broke CI on a fresh install; the reader is tested on 1.28. Moving to 2.0 needs its own pass over the table rules.
0.4.0
Markdown slide decks in
crepe-reader: one frame is one page (page_unit: slide); TikZ blocks are kept asdiagramitems instead of vanishing; relative figure paths are resolved through the deck's folder anddefaults.ymlresource-pathandget_assetattaches PDF, PNG, JPEG and SVG figures (when images are enabled);render_page_imageshows figure files; legacy.doc,.xlsand.pptfiles are converted once by LibreOffice (converted_frominopen_document) and read like their DOCX, XLSX and PPTX twins; sections keep their frame headings; slide figures without text are captioned by their frame; subtitle, author and date are reported; speaker notes withread_pages(notes=true); a deck that cites nothing has nouncitedlist; raw LaTeX text (slide titles set incenter) is kept.images.enabledis now on by default (Goose receives the images); set it tofalseinCREPE_READER_CONFIGfor an agent that drops them.
0.3.1
render_page_pngis nowrender_page_image(crepe-reader, a rename: update any prompt or script that names the old tool). It takesformat(png, the default, orjpeg) and renders pages of DOCX, ODT, RTF and PPTX as well as PDF; Office files are laid out by LibreOffice and the converted PDF is cached, so later pages are instant.New
list_changestool (crepe-reader, 9 tools now): tracked insertions, deletions and comments of a DOCX with author, date, the text a comment is attached to and the section.Reader fixes: a document with repeated caption numbers (a restarted appendix) no longer fails to open (the repeats become
table:1-2,table:1-3); pandoc runs with--sandbox, so a LaTeX\inputcannot pull in a local file or step outsideCREPE_READER_ROOTS;document_to_markdownrefuses to replace its source or an existing file unlessoverwrite=true;read_sectioncontinues long sections and oversized paragraphs with a cursor instead of cutting them silently.More reader fixes: nested list items and the code inside them are stored once (no doubled search hits); a heading followed by a long block no longer leaves an empty first page; tables keep every header row (
group / column) and merged cells keep their columns aligned;list_changesanchors survive nested comments and comments that span paragraphs; the converted Office PDFs behindrender_page_imageare owner-only and expire after 7 days of disuse.setup.py: JSON client configs (~/.claude.json, AGY) get a timestamped backup (the newest five are kept, so the original survives later installs) and are written atomically; an unchanged config is left alone.Worker pools are safer: a worker with unreadable output loses only its own pages (the parent computes them), and all geometry and render workers share one deadline instead of one timeout each.
One
.envloader: the second loader from the macOS merge (crepe_mcp._env, run at import) is removed;crepe_mcp.configis the only one. Semantic Scholar requests are paced and retried with backoff, and Playwright profiles are found under the system temp folder (macOS).Packaging and tooling: the sdist carries
setup.pyandskills/;ruff format --checkjoins the pre-commit and CI gate;crepe_mcp.__version__now follows the package version, with a test;dg.py --helpexits 0.
0.3.0 (breaking)
Monolith removed. The all-in-one
crepe-mcpserver andsetup.py --legacyare gone; use the six sub-servers (crepe-presentations,crepe-documents,crepe-research,crepe-spreadsheets,crepe-diagrams,crepe-reader)../setup.py --installand--uninstallalso remove the stalecrepeentry old installs wrote.API keys live in a
.envfile, loaded by the servers ($CREPE_ENV_FILE,~/.config/crepe-mcp/.env,./.env).setup.pyno longer readskeys.md, accepts--tavily-key/--ss-key, or writes keys into client configs. Move any key still present in an old client config into the.envand rotate it.New
crepe-readersub-server (8 tools) that reads PDF, DOCX, ODT, EPUB, HTML, LaTeX, Markdown, PPTX, XLSX and more.AGENTS.mdreplaced by thecrepeagent skill (skills/crepe/, Agent Skills format), installed to~/.agents/skills/crepe/bysetup.py.Tooling:
requirements.txtand thedevextra removed (pip install . --group test), pre-commit and CI share one gate with a coverage floor, and a hook rejects key-like literals.
License
MIT © Mário Antunes
Available Tools
17 toolsacademic_searchA
Search Semantic Scholar for academic papers. No API key required.
Returns up to limit results with title, link (open-access PDF preferred),
and truncated abstract (400 chars).
Inputs: query (required), limit. Returns: object
cleanup_presentationB
Delete a presentation's in-memory state and on-disk scratch dir.
Inputs: presentation_id (required). Returns: object
compile_presentationA
Compile the in-memory presentation to PDF or PPTX, writing directly to output_path (absolute). Call render_slides_as_pngs afterwards to validate visually.
format : 'pdf' (Beamer/lualatex) or 'pptx' (PowerPoint). theme : any Beamer theme name installed on this system (PDF only), default 'moloch'. highlight_style : code highlight style, default 'tango'. reference_doc : path to a .pptx template (PPTX only, optional).
Inputs: format (required), output_path (required), presentation_id (required), theme, +2 more. Returns: object
create_presentationA
Create a new, empty presentation; returns presentation_id, required by every other Group-A tool. All title-slide metadata is set here: title, optional subtitle, author, institute, date.
Inputs: title (required), date, author, subtitle, +1 more. Returns: object
delete_slideA
Remove a slide by index. Slides after it shift down by one.
expected_slide_count : optional, same stale-state guard as set_slide.
Inputs: index (required), presentation_id (required), expected_slide_count. Returns: object
export_presentation_sourceA
Return the pandoc source (slides Markdown + config.yml) this presentation compiles from.
output_dir : if given (absolute path), also writes slides.md/config.yml there. theme/highlight_style : same meaning as compile_presentation.
Inputs: presentation_id (required), theme, output_dir, highlight_style. Returns: object
fetch_webpageA
Extract readable plain text from a URL (http/https only). Uses the browser at CREPE_HEADLESS_BROWSER_PATH (--headless=new --dump-dom) if set, else falls back to urllib + HTML stripping with a warning.
Inputs: url (required), max_chars. Returns: object
get_presentationA
Return a presentation's metadata, ordered slide list (index, id, title, 200-char content preview), and which compiled artifacts exist.
Inputs: presentation_id (required). Returns: object
get_slideA
Return the full content of a single slide by its zero-based index.
Inputs: slide_index (required), presentation_id (required). Returns: object
import_presentation_sourceA
Replace a presentation's slides by parsing pandoc slide Markdown. Splits on '##' (slide) and bare '#' (section-divider) headings, ignoring '#' inside fenced code blocks.
presentation_id must already exist. Every slide it currently has is replaced; metadata is untouched. Exactly one of markdown (inline content) or source_path (absolute path to a .md file) must be given.
Inputs: presentation_id (required), markdown, source_path. Returns: object
list_presentationsA
List every presentation currently held in memory.
Inputs: no named parameters. Returns: object
render_slides_as_pngsA
Convert a compiled artifact to a numbered PNG sequence for visual validation. format must match a previously compiled artifact.
Inputs: format (required), presentation_id (required), dpi, output_dir. Returns: object
set_slideA
Add, replace, or insert a slide.
insert=False (default): index < slide count -> replace in place; index >= slide count -> append. insert=True: inserts at index, shifting that slide and everything after it later (index >= slide count still appends). Combine with delete_slide to move a slide to a new position.
content is raw Pandoc Markdown -- also supports speaker notes by
name alone. Exact syntax for three Beamer-specific conventions:
Incremental bullets : > - item
Section divider : content is ONLY "# Section Title", nothing else
Two-column layout : :::: {.columns}\n::: {.column width="50%"}\nLeft\n:::\n::: {.column width="50%"}\nRight\n:::\n::::
expected_slide_count : optional. If a concurrent call already changed the deck since you last checked, this fails with a clear error instead of silently landing at an unintended position -- get_presentation to refresh, then retry. Recommended when issuing several set_slide calls for the same presentation without waiting for each result first.
Inputs: index (required), title (required), content (required), presentation_id (required), +2 more. Returns: object
update_presentation_metadataA
Update title-slide metadata (title/subtitle/author/institute/date) on an existing presentation. Only fields given a value are changed.
Inputs: presentation_id (required), date, title, author, +2 more. Returns: object
web_searchA
Search the web via the Tavily API.
Requires CREPE_TAVILY_API_KEY in the environment. Returns an empty result with a warning field (not an error) if the key is absent, so the agent can surface the message gracefully.
Inputs: query (required), max_results. Returns: object
wikipedia_readA
Fetch the full plain-text body of a Wikipedia article.
title should be the exact article title from wikipedia_search.
Content is truncated to max_chars characters (default 15 000).
Inputs: title (required), max_chars. Returns: object
wikipedia_searchA
Search Wikipedia and return matching article titles, URLs, and excerpts.
Pass the returned title to wikipedia_read to fetch the full article.
Inputs: query (required), limit. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 17 tools
Every tool has a distinct target resource and action, from presentation lifecycle operations (create, get, set, delete, compile) to separate search sources (academic, web, Wikipedia, fetch URL). The only overlapping area is set_slide handling add/replace/insert, but its description clearly parameterizes the behavior.
Presentation tools consistently use verb_noun names (list_presentations, create_presentation, delete_slide, compile_presentation), but search tools shift to noun_verb order (academic_search, web_search, wikipedia_read). All names are snake_case and verbs are clear, so the inconsistency is moderate rather than chaotic.
17 tools sits in the borderline heavy range. The count is justified if the server intentionally combines presentation creation with research utilities, but the two distinct domains could feel bloated. Each subdomain alone would be well-scoped.
The presentation workflow covers the full lifecycle: create, read, update, delete, import/export, compile, and visual validation. The research tools handle web, academic, Wikipedia, and URL fetching. Minor gaps exist (e.g., no direct slide reordering, no academic PDF full-text fetch), but agents can achieve these with existing tools or workarounds.
Related MCP Connectors
MCP server for generating rough-draft project plans from natural-language prompts.
Driflyte MCP server which lets AI assistants query topic-specific knowledge from web and GitHub.
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
Markdown-based note-taking with a hosted MCP server. Your notes serve you and your AI.
Related MCP Servers
- AlicenseAqualityCmaintenanceMCP server for Deckrun — generate presentation PDFs, narrated videos, and audio from Markdown. Built for AI agents and IDEs. Free tier: no API key required — generate PDFs instantly. Paid tier: set DECKRUN_API_KEY to unlock video, audio, and account tools.22MIT
- AlicenseAqualityNot gradedmaintenanceAn MCP server that enables AI agents to instantly convert Markdown into beautiful, ready-to-deliver Word, PDF, HTML with sidebars, and Slideshow documents, bridging the "last mile" of AI content generation.728 npm1-

mcp-ToseaAIofficial
AlicenseBqualityBmaintenanceOfficial MCP server for ToseaAI that enables document-to-presentation workflows including PDF parsing, outline generation, and slide rendering. It provides a stable tool surface for AI agents to create, manage, and export presentations directly within their environment.211MIT- AlicenseNot gradedqualityFmaintenanceMCP server for generating slides from natural language, with interactive preview and export to PDF, PPTX, and Markdown.19MIT