How do I use pharos-ai-doc-genie?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@pharos-ai-doc-genie generate a 10-slide pitch deck on AI trends for CTOs" 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.

pharos-ai-doc-genie

by huimingchen081-beep

Overview Schema Related Servers Score Discussions

Python

Local

Pharos AI Doc Genie — Document Generation Skill

Built for Pharos Skill-to-Agent Dual Cascade Hackathon — Phase 1
A reusable, standardized Skill module that enables any AI Agent in the Pharos ecosystem to generate real Office documents (.pptx, .docx, .xlsx) and source code from natural language — powered by DashScope LLM API.

License: MIT Node.js MCP

🎯 Problem Statement

AI Agents in the Pharos economy need to produce tangible outputs — not just text responses. When an agent helps a user prepare a business proposal, it should deliver a real .docx file. When it analyzes data, it should produce an actual .xlsx spreadsheet. When it creates a presentation, it should output a .pptx that opens in PowerPoint.

Existing solutions either:

Generate plain text/Markdown that requires manual formatting
Depend on proprietary cloud APIs with unpredictable availability
Lack standardized interfaces for agent-to-skill communication

Pharos AI Doc Genie fills this gap with a production-ready, standardized Skill that generates real Office files and code from natural language.

Related MCP server: wps-mcp-server

🧩 Skill Architecture

┌──────────────────────────────────────────────┐
│                AI Agent (Pharos)              │
│         (Any MCP-compatible Agent)            │
└─────────────────┬────────────────────────────┘
                  │ MCP Protocol (JSON-RPC 2.0)
                  │ stdio transport
┌─────────────────▼────────────────────────────┐
│          Pharos AI Doc Genie Skill            │
│                                               │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐      │
│  │ generate │ │ generate │ │ generate │      │
│  │ _word    │ │  _ppt    │ │ _excel   │ ...  │
│  └────┬─────┘ └────┬─────┘ └────┬─────┘      │
│       │            │            │             │
│  ┌────▼────────────▼────────────▼──────┐      │
│  │        LLM (DashScope qwen)         │      │
│  │    Content Generation Layer         │      │
│  └────────────────┬────────────────────┘      │
│                   │                            │
│  ┌────────────────▼────────────────────┐      │
│  │     Python (python-pptx, etc.)      │      │
│  │     File Conversion Layer           │      │
│  │     Markdown → real .pptx/.docx     │      │
│  └────────────────┬────────────────────┘      │
└───────────────────┼───────────────────────────┘
                    │
         ┌──────────▼──────────┐
         │   Output Files      │
         │  .pptx  .docx       │
         │  .xlsx  .py/.js/... │
         └─────────────────────┘

Key design principles:

Stateless: Each tool call is independent — no session state needed
Idempotent: Same input produces consistent output structure
Self-contained: Zero external service dependencies beyond the LLM API
Standardized: MCP protocol ensures any compatible Agent can call it

🛠️ Tools (4 Skills)

Tool	Output	Use Case	Model
`generate_ppt`	`.pptx` presentation	Pitch decks, training, reports	qwen3.7-plus
`generate_word`	`.docx` document	Proposals, manuals, reports	qwen3.7-plus
`generate_excel`	`.xlsx` spreadsheet	Data tables, financials, inventory	qwen3.7-plus
`generate_code`	Source code (.py/.js/.go/...)	Rapid prototyping, boilerplate	qwen-long-latest

Tool Schema Examples

generate_ppt: Create a professional presentation

{
  "name": "generate_ppt",
  "arguments": {
    "topic": "AI in Enterprise: 2026 Trends",
    "requirements": "Executive summary for CTO audience, 12 slides, focus on ROI and adoption metrics",
    "slide_count": 12
  }
}

generate_excel: Generate structured data

{
  "name": "generate_excel",
  "arguments": {
    "description": "Q2 2026 sales data: Region, Product Category, Revenue, Units Sold, Growth%, Top Salesperson",
    "rows": 30
  }
}

🚀 Quick Start

Prerequisites

Node.js >= 18
Python 3.8+ with python-pptx, python-docx, openpyxl
DashScope API Key (Alibaba BaiLian)

Install Python dependencies

pip install python-pptx python-docx openpyxl

Run the MCP Server

node src/mcp-server.js

The server listens on stdin/stdout using the MCP stdio transport. Configure your Agent's MCP client to launch this process.

Test with MCP Inspector

npx @modelcontextprotocol/inspector node src/mcp-server.js

Manual Test (JSON-RPC via pipe)

echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}' | node src/mcp-server.js

📁 Project Structure

pharos-ai-doc-genie/
├── src/
│   └── mcp-server.js       # MCP stdio server (self-contained)
├── convert.py               # Python: Markdown → .pptx/.docx/.xlsx
├── output/                  # Generated Office files
├── package.json             # Node.js project config
├── README.md                # This file
├── LICENSE                  # MIT License
└── .gitignore

🔌 Integration

With Claude Desktop

{
  "mcpServers": {
    "pharos-ai-doc-genie": {
      "command": "node",
      "args": ["/absolute/path/to/pharos-ai-doc-genie/src/mcp-server.js"]
    }
  }
}

With OpenAI Agents

The server uses standard MCP tool schemas that are directly compatible with OpenAI function calling format. Simply configure your Agent to launch the server as an MCP subprocess.

With Pharos Agents

Pharos Agents can call this Skill via the MCP protocol. Once the Skill is registered, Agents discover it through tools/list and call it through tools/call.

🧪 Testing

# List available tools
echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | node src/mcp-server.js

# Generate a Word document
echo '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"generate_word","arguments":{"topic":"Project Proposal: AI Chatbot","requirements":"A formal proposal for building an enterprise AI chatbot. Include: executive summary, technical approach, timeline, budget estimate.","length":"medium"}}}' | node src/mcp-server.js

# Generate code
echo '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"generate_code","arguments":{"requirement":"A Python async function that fetches data from a REST API with exponential backoff retry logic","language":"python","comments":"en"}}}' | node src/mcp-server.js

⚡ Performance

Tool	Avg. Response Time	Max Tokens	File Size
generate_word	~20-40s	16384	30-50 KB (.docx)
generate_ppt	~30-60s	16384	25-40 KB (.pptx)
generate_excel	~15-25s	16384	5-15 KB (.xlsx)
generate_code	~15-30s	16384	N/A (text)

🔒 Security

No API key exposure: The DashScope API key is server-side only and never sent to Agents
Input validation: All Agent inputs are validated before processing
Output isolation: Generated files are written to a dedicated output directory
No persistent state: Each tool call is isolated with no cross-call data leakage

🗺️ Roadmap

Phase 2 (Agent Arena)

Deploy as a persistent Skill on Pharos chain
On-chain billing per document generation
NFT-based document ownership and verification
Multi-agent collaborative document editing

Beyond

PDF generation and manipulation
Image-to-document conversion (OCR → formatted docx)
Multi-language document templates
Real-time collaborative editing via WebSocket

👤 Author

huimingchen081-beep (GitHub)

Built for the Pharos Skill-to-Agent Dual Cascade Hackathon — Phase 1 (Skill Hackathon).

📄 License

MIT License — see LICENSE for details.

🙏 Acknowledgments

Pharos Network — for building the AI Agent economy infrastructure
DashScope (Alibaba BaiLian) — for the LLM API powering content generation
Model Context Protocol (Anthropic) — for the standardized agent-skill communication protocol
python-pptx / python-docx / openpyxl — for Office file generation

Available Tools

4 tools

generate_codeA

Generate production-ready source code in any programming language from natural language requirements. The AI writes complete, well-commented code following best practices and naming conventions. Use this for rapid prototyping, boilerplate generation, or educational examples.

ParametersJSON Schema

Name	Required	Description	Default
`requirement`	Yes	Detailed functional description, e.g. 'A Python async function that fetches data from REST API with retry logic and error handling'
`language`	Yes	Target programming language: python, javascript, typescript, java, go, rust, cpp, sql, html, css, etc.
`comments`	No	Comment language: 'en' for English, 'cn' for Chinese. Default: 'en'.	en

TDQS

A3.9/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so the description carries full burden. It mentions best practices and naming conventions but lacks details on code length, reliability, or limitations. It is not contradictory but could be more specific.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise with two sentences, front-loaded with the main action, and no wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 3 parameters and no output schema or annotations, the description adequately covers purpose but lacks details on output format, limitations, or edge cases. It is minimally complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description does not add significant meaning beyond what the input schema already provides for the parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool generates production-ready source code from natural language, specifying verb and resource, and distinguishes it from siblings like generate_excel, generate_ppt, and generate_word.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly suggests use cases: rapid prototyping, boilerplate generation, or educational examples. However, it does not explicitly state when not to use or mention alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate_excelA

Generate a structured data spreadsheet (.xlsx) from natural language description. The AI creates realistic, well-formatted data tables with proper headers and data rows. Use this for financial statements, sales data, inventory lists, or any tabular data.

ParametersJSON Schema

Name	Required	Description	Default
`description`	Yes	What data to generate, e.g. 'Monthly sales data with columns: Month, Product, Revenue, Units Sold, Growth%'
`rows`	No	Number of data rows to generate (5-100). Default: 20.

TDQS

A3.8/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It omits behavior details such as side effects, file handling, or limitations. Only mentions 'realistic, well-formatted data', not sufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, front-loaded with purpose, no fluff. Perfectly concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema, yet description does not state what the tool returns (e.g., file path, buffer). Missing crucial return information for a file generation tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%; description adds value with examples and clarifies default row count and range for the 'rows' parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states tool generates a .xlsx spreadsheet from natural language, with realistic tables. Sibling tools (generate_code, etc.) are distinct in purpose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly lists use cases like financial statements, sales data, but does not provide when-not-to-use or alternative tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate_pptA

Generate a professional PowerPoint presentation (.pptx) from natural language. The AI creates structured slide content with titles, bullet points, and visual suggestions. Use this when you need presentation slides, pitch decks, or training materials.

ParametersJSON Schema

Name	Required	Description
`topic`	Yes	The presentation topic, e.g. 'AI Trends 2026', 'Q2 Business Review', 'Product Launch Plan'
`requirements`	Yes	Detailed requirements: target audience, key points, tone, slide count preference
`slide_count`	No	Approximate number of slides (5-30). Default: 10.

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the burden. It states the AI creates structured slide content with titles, bullet points, and visual suggestions, which gives basic behavioral insight. However, it does not disclose constraints, output handling, or potential side effects, leaving some gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences long with no wasted words. The first sentence states the core function and output format, and the second explains the AI's role and usage guidance. Every sentence serves a clear purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 3 parameters and no output schema, the description covers the essential purpose and usage. It explains what the tool creates and when to use it. It could be more complete by mentioning how the result is returned (e.g., file download or link), but overall it is sufficient for agent understanding.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with each parameter already described. The description adds general context (e.g., 'from natural language') but does not provide parameter-specific details beyond what the schema already offers. As baseline, this is adequate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool generates a PowerPoint presentation (.pptx) from natural language, and mentions creating structured slide content. It also provides specific use cases (presentation slides, pitch decks, training materials), distinguishing it from sibling tools like generate_code, generate_excel, and generate_word.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description includes explicit usage guidance: 'Use this when you need presentation slides, pitch decks, or training materials.' This clearly indicates when to use the tool. However, it does not provide explicit negative examples or alternatives beyond what sibling names imply.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate_wordA

Generate a complete Word document (.docx) from natural language. The AI creates well-structured content with headings, paragraphs, bullet points, and proper formatting. Use this for proposals, reports, meeting minutes, manuals, or any formal document.

ParametersJSON Schema

Name	Required	Description	Default
`topic`	Yes	Document topic, e.g. 'Project Proposal', 'API Documentation', 'Annual Report'
`requirements`	Yes	Document purpose, target readers, key sections, tone (formal/casual/technical), length preference
`length`	No	Expected length: 'short' (~500 words), 'medium' (~1500 words), 'long' (~3000+ words)	medium

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden. It discloses that the output includes 'headings, paragraphs, bullet points, and proper formatting' but lacks details on potential limitations (e.g., file size, images, tables) or side effects. Additional behavioral context would improve transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences plus an example list, with the purpose front-loaded. Every sentence adds value, and there is no redundancy. Highly concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 3 parameters with full schema coverage and no output schema, the description adequately covers the tool's purpose, typical use cases, and expected output characteristics. It does not explain return values explicitly, but that is not required. Minor gaps in limitations transparency, but overall complete for its complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description does not add meaning beyond what the schema provides for parameters; it only states 'from natural language' which aligns with the schema. No additional semantic details are given.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Generate') and resource ('Word document (.docx) from natural language') and explicitly lists example uses (proposals, reports, meeting minutes, manuals) which clearly distinguishes it from sibling tools like generate_code, generate_excel, and generate_ppt.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear usage contexts ('Use this for proposals, reports, meeting minutes, manuals, or any formal document') but does not explicitly state when not to use or mention alternatives. However, the siblings are distinct enough that no exclusion is needed.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.2/5.0

Disambiguation5/5

Each tool generates a distinct type of output (code, spreadsheet, presentation, word document), making them easily distinguishable. There is no overlap in purpose or output format.

Naming Consistency5/5

All tools follow a consistent 'generate_' prefix pattern, making the naming uniform and predictable. The verb 'generate' is appropriate for the creation-oriented domain.

Tool Count5/5

With only 4 tools, the set is tightly scoped to common file generation tasks. Each tool serves a clear, non-redundant purpose, and the count is well-suited for a specialized server.

Completeness4/5

The set covers the most common generation needs (code, Excel, PowerPoint, Word). Minor gaps like PDF or CSV generation exist, but these are not critical for the core use case.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

agentdocs
io.github.dancourse
An agent-first office suite Claude & ChatGPT read and write over one MCP URL.
Workplace & Productivity Documentation Access
2
Frenchie A
io.github.Lab94
OCR, transcription, file extraction, and image generation for AI agents via MCP.
AI & Machine Learning Image & Video Processing Speech Processing
72
powerpoint-engine
io.powerpointengine
Generate, edit, merge, translate and PDF-convert PowerPoint (.pptx) over MCP. 8 tools.
Workplace & Productivity File Systems
2
superdocs
app.superdocs
AI document editing for agents: draft, edit, export .docx/PDF. 37 MCP tools; agent self-signup.
Workplace & Productivity Text Summarization
21

Related MCP Servers

docforge-mcp
Workplace & Productivity Developer Tools
filhocf
A
license
B
quality
D
maintenance
Enables complete Office document lifecycle management for AI agents, including creation, editing, conversion, and templating of DOCX, XLSX, PPTX, PDF, and EML files.
Updated a month ago (2026-07-21 19:04 UTC)
40
MIT
wps-mcp-server
Workplace & Productivity File Systems
Xiao-rx
A
license
Not graded
quality
D
maintenance
Enables AI agents to natively create and edit WPS Office documents, spreadsheets, and presentations via natural language commands.
Updated 5 months ago (2026-04-08 03:09 UTC)
16
MIT
InkPaw
Workplace & Productivity Developer Tools
syouro
A
license
Not graded
quality
B
maintenance
Enables AI agents to generate, edit, validate, and render Word documents programmatically via MCP, ensuring correct OOXML structure and style.
Updated a month ago (2026-08-08 20:01 UTC)
3
MIT
HiveMCP
Workplace & Productivity App Automation
traxonLp
A
license
Not graded
quality
A
maintenance
MCP server that generates and edits PowerPoint, Word, and Excel files for OpenWebUI, exposing both MCP and OpenAPI interfaces for document creation and editing.
Updated a day ago (2026-09-02 15:50 UTC)
1
MIT

Appeared in Searches

OfficeCLI - Command Line Interface Tool for Office

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/huimingchen081-beep/pharos-ai-doc-genie'

If you have feedback or need assistance with the MCP directory API, please join our Discord server