> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dedaluslabs.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Python Framework

> Build production MCP clients and servers with the Dedalus Python framework.

<Note>
  Python is the recommended production path for the Dedalus MCP Framework today. Source:
  [dedalus-labs/dedalus-mcp-python](https://github.com/dedalus-labs/dedalus-mcp-python).
</Note>

We believe MCP is the interface between models and the world. To use any tools, we believe it must be:

1. **Secure**: Credentials handled correctly and securely.
2. **Modular**: Tools that compose, instead of locked to one server.
3. **Spec-faithful**: Every behavior traceable.

With Dedalus MCP, we achieve all above. We don't bundle CLI scaffolding or opinionated middleware. We integrate with your existing stack.

## What is MCP?

Model Context Protocol (MCP) is a standard for AI agents to interact with external services. Instead of hardcoding integrations, you expose **tools** (functions), **resources** (data), and **prompts** (templates) that any MCP-compatible client—Claude, GPT, Cursor—can discover and use.

Think of it as a universal API for agent capabilities: you define what's available, the model decides when to use it.

## Why Dedalus

### Security by Default

Other frameworks leave authentication as an exercise for the server builder. We built [DAuth](/sdk/mcp/python/authorization):

* **Zero-trust**: Dedalus never sees raw API keys or access tokens.
* **Hardware enclave**: Credentials are validated momentarily, then zeroed from memory.
* **Host-blind**: Credentials are encrypted client-side before leaving your device.
* **Intent-based**: Define access intents (e.g., `slack_read`) to prevent permission hijacking.

Production-grade auth in a few lines of code, not weeks of infrastructure work.

### Modular Servers

Most MCP frameworks couple tools to servers:

```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
from fastmcp import FastMCP

mcp = FastMCP(name="CalculatorServer")

# Tool is bound to this server instance
@mcp.tool
def add(a: int, b: int) -> int:
    return a + b
```

Dedalus decouples decoration from registration:

```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
from dedalus_mcp import tool

# @tool attaches metadata. That's it.
@tool
def add(a: int, b: int) -> int:
    return a + b

# collect() registers. Same tool, multiple servers.
server_a.collect(add)
server_b.collect(add)
```

Tools become portable units. No global state. Tests stay isolated. Functions work everywhere.

### MCP Observability and Versioning

MCP has multiple spec versions with real behavioral differences. Unlike other frameworks, Dedalus MCP tracks exactly which version your client negotiated.

### Fast and Production Ready

**122 KB**. FastMCP is 8.6 MB—**70× smaller**. We ship **code**, not dependencies.