polymcp

polymcp agent run \ --type polyclaw \ --query "Build a sales reporting pipeline and test it end-to-end" \ --model minimax-m2.5:cloud \ --verbose What happens behind the scenes: 1. The task is decomposed into structured steps 2. Required MCP tools are identified 3. MCP servers are started or connected 4. Steps execute (sequentially or in parallel) 5. Outputs are validated 6. Failures trigger adaptive replanning 7. A complete, end-to-end result is returned All containerized. All isolated. ⸻ Why This Matters Most AI agents today: • Call tools statically • Assume infrastructure already exists • Break on multi-step failures PolyClaw instead: • Builds the infrastructure it needs • Orchestrates across multiple MCP servers • Handles retries and adaptive planning • Is safe to run in Dockerized environments This makes it viable for: • Enterprise workflows • DevOps automation • Data pipelines • Internal tooling orchestration • Complex multi-tool reasoning tasks PolyClaw turns PolyMCP from simple tool exposure into a fully autonomous orchestration layer. Repo: https://github.com/poly-mcp/PolyMCP Happy to answer questions.

ild a sales reporting pipeline and test it end-to-end" \ --model minimax-m2.5:cloud \ --verbose What happens behind the scenes: 1. The agent decomposes the task. 2. It determines which MCP tools are required. 3. It spins up or connects to MCP servers. 4. It executes steps in sequence (or parallel when needed). 5. It validates outputs. 6. It adapts if something fails. 7. It returns a complete result. All containerized. All isolated. ⸻ Why This Matters Most AI agents: • Call tools statically • Assume infrastructure already exists • Break on multi-step failure PolyClaw: • Builds the infrastructure it needs • Orchestrates across multiple MCP servers • Handles retries and adaptive planning • Is safe to run in Dockerized environments This makes it viable for: • Enterprise workflows • DevOps automation • Data pipelines • Internal tooling orchestration • Complex multi-tool reasoning tasks PolyClaw turns PolyMCP from simple tool exposure only with Polyagent e unifiendpolyagent or codeagent but turn into full autonomous orchestration agent too. Repo: https://github.com/poly-mcp/PolyMCP Happy to answer questions,

lue code between models and tools. Instead of manually wiring everything together for each new setup, PolyMCP offers a structured way to: • Register tools as MCP servers • Attach them to one or more agents • Explicitly manage execution flow and state • Inspect and debug interactions It’s MIT licensed and aimed at developers building production-grade automation, internal copilots, or multi-tool assistants. Repository: https://github.com/poly-mcp/PolyMCP

pute totals, then summarize.") print(answer) Or TypeScript, combining HTTP and stdio-based MCP tools: import { UnifiedPolyAgent, OpenAIProvider } from 'polymcp-ts'; const agent = new UnifiedPolyAgent({ llmProvider: new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY!, model: 'gpt-4o-mini', }), mcpServers: ['http://localhost:3000/mcp'], stdioServers: [{ command: 'npx', args: ['@playwright/mcp@latest'] }], verbose: true, }); await agent.start(); const answer = await agent.run('Collect data and summarize.'); console.log(answer); Use cases: • Aggregate data from multiple internal services and scripts • Build AI copilots that span different tools and languages • Automate multi-step operational workflows • Prototype agents that interact with production systems safely Works with OpenAI, Anthropic, and Ollama models, including local deployments. GitHub links: • Core & Agent: https://github.com/poly-mcp/PolyMCP • Inspector: https://github.com/poly-mcp/PolyMCP-Inspector • SDK Apps: https://github.com/poly-mcp/PolyMCP-MCP-SDK-Apps I’d love feedback from anyone exploring agent orchestration or building multi-tool AI pipelines.

y: multiple tools in one WASM bundle • Ideal for interactive demos, edge AI apps, or browser-based automation Repo: https://github.com/poly-mcp/Polymcp

the painful part. Most solutions require rewriting logic around a specific SDK or heavily annotating functions. PolyMCP focuses on: • Minimal intrusion into existing code • Clean separation between business logic and AI tooling • Easy debugging via a visual inspector Example use cases • Expose internal APIs or legacy scripts to LLM agents • Automate operational workflows • Build internal copilots over real systems • Prototype AI agents that interact with production services Works with OpenAI, Anthropic, and Ollama (including local models). It’s still evolving and I’m actively iterating. I’d really appreciate feedback — especially from people building agents or experimenting with MCP in production environments. GitHub: • Core: https://github.com/poly-mcp/PolyMCP • Inspector: https://github.com/poly-mcp/PolyMCP-Inspector • SDK Apps: https://github.com/poly-mcp/PolyMCP-MCP-SDK-Apps Happy to answer technical questions.

corators, no schema files, no agent-specific SDKs. ⸻ 2) Real APIs, not toy examples Existing API code works as-is: import requests from polymcp import expose_tools_http def get_weather(city: str): """Return current weather data for a city""" response = requests.get( f"https://api.weatherapi.com/v1/current.json?q={city}" ) return response.json() app = expose_tools_http([get_weather], title="Weather Tools") Agents can now call: get_weather("London") and receive real-time data. ⸻ 3) Business & internal workflows Example: internal reporting logic reused directly by agents. import pandas as pd from polymcp import expose_tools_http def calculate_commissions(sales_data: list[dict]): """Calculate sales commissions from sales data""" df = pd.DataFrame(sales_data) df["commission"] = df["sales_amount"] * 0.05 return df.to_dict(orient="records") app = expose_tools_http([calculate_commissions], title="Business Tools") No rewriting legacy logic. 4) PolyMCP Inspector (visual debugging) To make MCP development usable in practice, I added PolyMCP Inspector: • Visual UI to browse tools, prompts, and resources • Call MCP tools interactively • Inspect schemas, inputs, outputs, and errors • Multi-server support (HTTP + stdio) • Built-in chat playground (OpenAI / Anthropic / Ollama) Think “Postman + DevTools” for MCP servers. Repo: https://github.com/poly-mcp/PolyMCP-Inspector ⸻ 5) MCP SDK Apps (tools + UI) The latest addition is PolyMCP MCP SDK Apps: • Build MCP apps, not just tools • Expose: • tools • UI resources (HTML/JS dashboards) • app-level workflows • Let agents interact with both tools and UIs This is useful for: • internal copilots • ops dashboards • support tools • enterprise AI frontends Repo: https://github.com/poly-mcp/PolyMCP-MCP-SDK-Apps ⸻ Why this matters (especially for companies) • Reuse existing code immediately (scripts, APIs, internal libs) • Standard MCP interface instead of vendor-specific agent SDKs • Multiple tools, one server • Agent-driven orchestration, not hardcoded flows • Faster AI adoption without refactoring everything PolyMCP treats AI agents as clients of your software, not magic wrappers around it. ⸻ Repos • Core framework: https://github.com/poly-mcp/PolyMCP • Inspector UI: https://github.com/poly-mcp/PolyMCP-Inspector • MCP SDK Apps: https://github.com/poly-mcp/PolyMCP-MCP-SDK-Apps Happy to hear feedback from people building MCP servers, agents, or internal AI tools.

on, and others supported by Ollama. The goal is to provide a straightforward way to experiment with and deploy LLM-powered agents without extra glue code. Would love feedback or ideas on how you’d use this. Repo: https://github.com/poly-mcp/Polymcp

ext: z.string() }), function: async ({ text }) => text.toUpperCase(), }); const app = exposeTools([uppercaseTool], { title: "Text Tools" }); app.listen(3000); More “real” example (Python) import pandas as pd from polymcp.polymcp_toolkit import expose_tools def calculate_commissions(sales_data: list[dict]): df = pd.DataFrame(sales_data) df["commission"] = df["sales_amount"] * 0.05 return df.to_dict(orient="records") app = expose_tools([calculate_commissions], title="Business Tools") What you get • Reuse existing code with minimal changes • MCP-compatible (Claude Desktop, agents, Ollama, etc.) • HTTP, stdio, and WASM support • Automatic input validation • Basic production features (budgets, retries, redaction, logs) • Built-in inspector for testing and monitoring Install • Python: pip install polymcp • TypeScript: clone repo → cd polymcp-ts → npm install → npm run build Repo: https://github.com/poly-mcp/Polymcp Curious what kind of function people would expose first if it was this easy. Feedback very welcome.

sten(3000); Business example (Python): import pandas as pd from polymcp.polymcp_toolkit import expose_tools def calculate_commissions(sales_data: list[dict]): df = pd.DataFrame(sales_data) df["commission"] = df["sales_amount"] * 0.05 return df.to_dict(orient="records") app = expose_tools([calculate_commissions], title="Business Tools") What you get: • Reuse existing code with minimal changes • Compatible with MCP clients (Claude Desktop, agents, Ollama, etc.) • HTTP and stdio and Wasm support • Automatic validation • Basic production features (budgets, retries, redaction, logs) • Inspector: polymcp inspector for testing/monitoring Install: • Python: pip install polymcp • TypeScript: clone repo → cd polymcp-ts → npm install → npm run build Repo: https://github.com/poly-mcp/Polymcp Curious what kind of function people would expose first if it was this simple. Feedback welcome.

}); app.listen(3000); Agents can call uppercase("hello") and get "HELLO" instantly. Business workflow function (Python example): import pandas as pd from polymcp.polymcp_toolkit import expose_tools_http def calculate_commissions(sales_data: list[dict]): df = pd.DataFrame(sales_data) df["commission"] = df["sales_amount"] * 0.05 return df.to_dict(orient="records") app = expose_tools_http([calculate_commissions], title="Business Tools") Now AI agents can generate reports automatically. Why it matters • Reuse existing code immediately: legacy scripts, internal libraries, APIs. • Automate workflows: AI can orchestrate multiple tools reliably. • Cross-language: expose Python and TypeScript functions on the same MCP server. • Plug-and-play: no custom wrappers or middleware needed. • Built-in reliability: input/output validation and error handling included. PolyMCP makes any Python or TypeScript function immediately usable by AI agents, standardizing integration across enterprise software. Repo: https://github.com/poly-mcp/Polymcp

" \ --output ./mcp_skills Enable skills in an agent: agent = UnifiedPolyAgent( llm_provider=llm, skills_enabled=True, skills_dir="./mcp_skills", ) Benefits: • Smaller agent context • Scales to large tool sets • Reusable capabilities across agents • Tool access control without prompt changes • Works with HTTP and stdio MCP servers Repo: https://github.com/poly-mcp/Polymcp