Skip to main content

Platools SDK + Platos Platform

Your AI Arsenal

Platos turns any Python or TypeScript function into an authenticated, monitored MCP tool - and gives you the agent runtime, memory, orchestration, and dashboard to ship production AI apps.

See it in action GitHub
example.py 
from platools import tool
from pydantic import BaseModel

class BalanceIn(BaseModel):
    account_id: str

@tool(name="check_balance", description="Get account balance by id")
def check_balance(args: BalanceIn) -> dict:
    return {"balance_cents": fetch_balance(args.account_id)}

Everything the agent runtime needs

Out of the box

Six load-bearing pillars - built to the latency budgets in the PRD

and wired through a single Docker Compose.

  • Smart Tool Selection

    Sub-10ms vector scoring picks the right tools for every request. No LLM in the selection path, no wasted tokens.

  • Three-Tier Memory

    Redis warm cache (< 1ms), pgvector semantic memory (< 10ms), knowledge graph (< 20ms p95). Agents remember without drowning in context.

  • MCP Gateway with OAuth

    Official Model Context Protocol over Streamable HTTP. OAuth 2.1 with PKCE, per-endpoint rate limits, tool allowlists. Works in Claude Desktop, Cursor, any MCP client.

  • BYOK Everything

    Bring your own keys: Anthropic, OpenAI, Google, Bedrock, Azure, Groq, Mistral, Ollama, 15+ providers via LiteLLM. We never touch your model inference billing.

  • Multi-Agent Orchestration

    DAG engine with Celery workers, build-time + runtime tool scoping, visual React Flow builder, conditional branches, human-in-the-loop.

  • Production Monitoring

    Tool call logs with p50/p95/p99, hallucination detection (6 signals), PII + prompt injection safety, per-run cost tracking. Ship with receipts.

How Platos is different

FastMCP is Flask. Platools is Heroku. Here is where the line is drawn.

vs. FastMCP

FastMCP gives you a bare MCP server. Platos gives you the whole ops stack around it: auth, rate limits, monitoring, memory, tool groups, OAuth proxy, BYOK providers.

  • Auth + rate limits built in
  • OAuth 2.1 proxy for every org
  • Tool health + p95 monitoring

vs. LangChain / CrewAI

Framework-for-Python approaches put you in charge of every loop. Platos is a runtime: you decorate functions, run platools doctor, and the platform handles registry, scoping, routing, and observability.

  • Decorator-first, not loop-first
  • Smart selection over prompt bloat
  • Dashboard + eval suite included

vs. Rolling Your Own

Three-tier memory, smart selection, MCP gateway with OAuth, orchestration, and a full dashboard in one Docker Compose file. No months of infra work before you ship your first agent.

  • One-command Compose deploy
  • Reversible migrations by default
  • Self-host or use managed

Quick start

Four steps from empty terminal to a running MCP tool. Copy, paste, ship.

zsh - platos 
# 1. Install the SDK
pip install platools
# or: npm install @platools/sdk (TypeScript, coming soon)

# 2. Decorate a function
cat > example.py <<'EOF'
from platools import tool
from pydantic import BaseModel

class FlightIn(BaseModel):
    pnr: str
    last_name: str

@tool(name="get_flight_details", description="Look up a flight by PNR")
def get_flight_details(args: FlightIn) -> dict:
    return {"flight_number": "BA245", "gate": "B42"}
EOF

# 3. Run the SDK doctor + test
platools doctor example.py       # lints schema, auth, and output shape
platools test example.py         # runs the test harness

# 4. Ship it - deploy the whole platform with one command
curl -fsSL https://get.platos.dev | sh   # (or git clone + make up)

One Compose file, every layer

Your code stays in your infra. The SDK dials out over WebSocket; the platform handles everything else.

Your app

Python or TypeScript

Platools SDK

Outbound WebSocket

Platos platform

FastAPI + Pydantic AI

Memory layer

3-tier

Redis · pgvector · knowledge graph. Writes are async, reads are under 20ms p95.

Orchestration

DAG engine

Celery workers, build-time + runtime tool scoping, human gates.

MCP gateway

OAuth 2.1

Streamable HTTP, PKCE, per-endpoint rate limits, encrypted token vault.

Ready to build?

Read the docs