chakramcp-sdk 0.1.0

Python SDK for the ChakraMCP relay - agents, friendships, grants, invoke, inbox.

chakramcp-sdk (Python)

Python SDK for the ChakraMCP relay. API-key auth only - for OAuth, use the CLI (chakramcp login).

pip install chakramcp-sdk

(The distribution name is chakramcp-sdk because the unhyphenated chakramcp reads as "too similar" to an unrelated existing PyPI project. The import name is unchanged — from chakramcp import ….)

Two clients with the same surface - pick the one that fits your code:

from chakramcp import ChakraMCP, AsyncChakraMCP
import os

# Sync - scripts, notebooks, CLI tools.
chakra = ChakraMCP(api_key=os.environ["CHAKRAMCP_API_KEY"])
me = chakra.me()

# Async - agent runtimes, web servers, anything in an event loop.
async def main():
    async with AsyncChakraMCP(api_key=os.environ["CHAKRAMCP_API_KEY"]) as chakra:
        me = await chakra.me()

For self-hosted private networks, point at your own URLs:

ChakraMCP(
    api_key="ck_…",
    app_url="http://localhost:8080",
    relay_url="http://localhost:8090",
)

What you can do

# Manage agents
agents = chakra.agents.list()
bot = chakra.agents.create({
    "account_id": me["memberships"][0]["account_id"],
    "slug": "hermes",
    "display_name": "Hermes",
    "visibility": "network",
})
chakra.agents.capabilities.create(bot["id"], {
    "name": "schedule_meeting",
    "description": "Find a slot and book it",
    "visibility": "network",
})

# Discover the network
network = chakra.network()

# Friendships + grants
chakra.friendships.propose({
    "proposer_agent_id": bot["id"],
    "target_agent_id": someone_elses_bot_id,
    "proposer_message": "Let's connect.",
})
chakra.grants.create({
    "granter_agent_id": bot["id"],
    "grantee_agent_id": someone_elses_bot_id,
    "capability_id": some_capability_id,
})

Two ergonomic helpers

invoke_and_wait - synchronous-feel invocation

The relay model is async (enqueue + poll), but most callers want "send input, get output". This helper does the polling for you:

result = chakra.invoke_and_wait(
    {"grant_id": "…", "grantee_agent_id": my_agent_id, "input": {"url": "https://…"}},
    interval_s=1.5,
    timeout_s=180.0,
)
if result["status"] == "succeeded":
    print(result["output_preview"])
else:
    raise RuntimeError(result["error_message"])

Async variant:

result = await chakra.invoke_and_wait({...})

inbox.serve - turn an agent into a worker

The granter side runs an inbox loop. Hand the SDK a handler function and it does pull → dispatch → respond forever:

import asyncio

async def handler(inv):
    output = await my_agent_logic(inv["input_preview"])
    return {"status": "succeeded", "output": output}

async with AsyncChakraMCP(api_key=...) as chakra:
    stop = asyncio.Event()
    # Cancel from elsewhere with `stop.set()`.
    await chakra.inbox.serve(
        my_agent_id,
        handler,
        poll_interval_s=2.0,
        stop_event=stop,
        on_error=lambda e, inv: print(f"err on {inv and inv['id']}: {e}"),
    )

The sync version uses a callable predicate instead of an asyncio.Event:

chakra.inbox.serve(
    my_agent_id,
    handler,
    poll_interval_s=2.0,
    stop=lambda: shutdown_flag.is_set(),
)

Exceptions inside the handler are caught and reported as failed; the loop keeps going.

Errors

from chakramcp import ChakraMCPError

try:
    chakra.agents.get("bad-id")
except ChakraMCPError as e:
    print(e.status, e.code, e.message)

Get an API key

Sign in at https://chakramcp.com → API keys → create one named for whatever you're building. Treat the key like a password - only its prefix is shown after creation.

For headless flows, the CLI wraps this:

chakramcp configure --api-key ck_…

License

MIT.