agentor

Agentor provides a LiteMCP-based MCP server that lets you expose an agent as an MCP-compatible service with lightweight token-based access control. The LiteMCP setup integrates with FastAPI-style patterns and supports standard MCP tooling, including single-endpoint interaction, task management, and A2A protocol compatibility. You can define an MCP server that hosts tools and methods, enable authentication via the built-in get_token mechanism, and serve the endpoint so other agents or clients can invoke functions, stream results, and exchange tasks. This makes it straightforward to deploy durable, observable AI agents that can participate in a network of MCP servers and agents.

To run your MCP server, install the Python package and start the server module. The server exposes a REST-like interface compatible with the MCP protocol and leverages LiteMCP under the hood. You can define tools and endpoints within your Python code, expose them through the mcp server, and serve them with a simple serve() call. Agents and other MCP peers can then discover capabilities, invoke methods, and share tasks using the A2A protocol when enabled. The README examples show how to build a Weather Agent and expose it via an MCP server, illustrating how to integrate tooling, authentication, and serving into a cohesive deployment.

Prerequisites:

• Python 3.8+ installed on your system
• Git (optional, for cloning sources)

Installation (from PyPI):

pip install agentor

Optional: Install latest bleeding-edge version from GitHub (unstable):

pip install git+https://github.com/celestoai/agentor@main

Verify installation:

python -c "import agentor; print(agentor.__version__)"

Usage quickstart (example):

1. Create a LiteMCP server in Python (see docs for details):

from agentor.mcp import LiteMCP, get_token

mcp = LiteMCP(name="my-server", version="1.0.0")

@mcp.tool(description="Get weather for a location")
def get_weather(location: str) -> str:
    token = get_token()
    if token != "SOME_SECRET":
        return "Not authorized"
    return f"Weather in {location}: Sunny, 72°F"

mcp.serve()

2. Run your MCP server script:

python path/to/your_mcp_script.py

3. Interact with the server via HTTP/MCP endpoints once running (as documented in the repo examples).

Tips and common considerations:

• Authentication: Use get_token() within your MCP tools to enforce simple token-based access control. Consider rotating tokens and securing them in environment variables or secret managers.
• Port and host: The serve() method typically binds to a default port; configure as needed to fit your deployment (e.g., behind a gateway or reverse proxy).
• A2A readiness: If you enable A2A, agents can discover your endpoint at standard locations (e.g., /.well-known/agent-card.json) and communicate using JSON-RPC- or REST-like messaging.
• Observability: Leverage built-in tracing and monitoring as described in the docs to observe tool invocations and task status across the MCP server.
• Tool registration: Define tools with descriptive metadata so other agents can discover capabilities and usage requirements easily.
• Environment variables: For production, store secrets (like tokens) in environment variables or a secret manager rather than hard-coding them.
• Compatibility: LiteMCP aims to integrate with standard FastAPI patterns; if you have an existing FastAPI app, you can mount or integrate the MCP server module accordingly.