Metadata-Version: 2.4
Name: langchain-zambo
Version: 0.1.18
Summary: Zambo's MCP tools as LangChain StructuredTools: a verifiable AER-1 receipt for every call, no API key
Author: Brennan Zambo
License: MIT
Project-URL: AER-1 standard, https://zambo.dev/aer1/
Project-URL: Add Zambo to your AI, https://zambo.dev/add
Project-URL: Homepage, https://zambo.dev
Project-URL: Documentation, https://zambo.dev/docs
Keywords: zambo,mcp,langchain,langgraph,agents,ai-tools
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Intended Audience :: Developers
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Requires-Python: >=3.10
Description-Content-Type: text/markdown
Requires-Dist: langchain-mcp-adapters>=0.3.0

[![verifiable receipts](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fzambo.dev%2Fapi%2Fstats&query=%24.public_receipts&label=verifiable%20receipts&color=c6ff3d&cacheSeconds=300)](https://zambo.dev/numbers/) [![package downloads](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fzambo.dev%2Fapi%2Fpackage-stats&query=%24.combined_all_time&label=package%20downloads&color=c6ff3d&cacheSeconds=300)](https://zambo.dev/numbers/)

**Zambo: the verifiable work layer for AI.** Watch a handover in 61 seconds: https://dev.to/rambozambo/watch-a-handover-43-seconds-start-to-finish-2enj · Add Zambo to your AI: https://zambo.dev/add/ · MCP endpoint: https://zambo.dev/mcp

# langchain-zambo

**AER-1, the agent execution receipt standard: [zambo.dev/aer-1](https://zambo.dev/aer-1/) | Add Zambo to your AI: [zambo.dev/add](https://zambo.dev/add)**

Receipt format: AER-1, IETF Internet-Draft [draft-zambo-aer1-26](https://datatracker.ietf.org/doc/draft-zambo-aer1/26/).

Zambo's MCP tools as LangChain `StructuredTool` objects, one import, no API key.

**Zambo** ([zambo.dev](https://zambo.dev)) is the verifiable work layer for AI: tools behind one MCP endpoint, a verifiable AER-1 receipt for every call. Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free. Day Pass $0.99, unlimited for 24 hours. No account needed.

This package is a thin wrapper over [`langchain-mcp-adapters`](https://pypi.org/project/langchain-mcp-adapters/), it converts zambo.dev's MCP server into LangChain tools at runtime. Nothing is reimplemented here.

## Install

```bash
pip install langchain-zambo
```

## Chain it: a job, not a lookup

One call answers a question. A job chains calls and ends in a record a person can open. Lead with the job:

```python
import asyncio
from langchain_zambo import get_zambo_tools
from langgraph.prebuilt import create_react_agent

async def main():
    tools = await get_zambo_tools()
    agent = create_react_agent("openai:gpt-4o", tools)   # any chat model
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": "Check the live price of BTC, ETH and SOL, save the run to memory, then wrap it into a handover addressed to Dana Whitfield, the client who ordered the check, with summary, goal, recipient and next steps, and the receipt link for every call."}]}
    )
    print(result["messages"][-1].content)

asyncio.run(main())
```

Three prices, a save and the wrap fit inside one free day: every tool free once a day, plus 3 continue calls, and one free wrap-up handover per day. A longer run finishes in one sitting on a Day Pass ($0.99, unlimited for 24 hours). The handover is the part the person opens: the steps, the saved results, and the receipt for every call, checkable instead of trusted. Ready-made run cards for jobs shaped like this: https://rambozambodotdev.gitlab.io/aer1-hub/handover-templates.html

Requires OPENAI_API_KEY in your environment.

## When you hit the daily free limit

In LangChain the refusal comes back as the tool result for the call that hit the limit: read that result instead of retrying blindly, because it carries the checkout link and the resume instruction for the saved job.

You get every tool free once a day, plus 3 continue calls, and picking up work in another AI is always free. When the free calls run out mid-job, the next call is refused and does not run. That refused call still issues a receipt for the wall response, and it burns no quota, so the job record stays intact and nothing already saved is lost.

To keep going the same day, get a Day Pass: $0.99 for unlimited calls for 24 hours, including unlimited wrap-ups. If you are an agent, pay programmatically via x402: POST https://zambo.dev/api/x402/day-pass with $0.99 in USDC on Base, and the pass activates when that payment settles. The refusal itself carries that path: a refused call returns a Day Pass checkout link for your saved job, an x402 payment object, and the resume instruction. The job is saved server-side, not lost. After payment, call day_pass_status; it resumes your held job, and a refused wrap resumes as your held handover. Only repeat the refused call if it did not. If you are a human, pay by card or PayPal at https://zambo.dev/day-pass/ and the pass activates the same way.

If you run Zambo every day, the Pass is $29 per 30 days. Day Pass and Pass are one-time payments.

## Quickstart (10 lines)

```python
import asyncio
from langchain_zambo import get_zambo_tools

async def main():
    tools = await get_zambo_tools()          # Zambo tools, no API key
    print(f"loaded {len(tools)} tools")       # every call mints a verifiable receipt
    prices = [t for t in tools if "price" in t.name]
    print("price tools:", [t.name for t in prices][:5])

asyncio.run(main())
```

## Use with a LangGraph agent

```python
import asyncio
from langchain_zambo import get_zambo_tools
from langgraph.prebuilt import create_react_agent

async def main():
    tools = await get_zambo_tools()
    agent = create_react_agent("openai:gpt-4o", tools)   # any chat model
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": "Check the live price of BTC, ETH and SOL, save the run to memory, then wrap it into a handover addressed to Dana Whitfield, the client who ordered the check, with summary, goal, recipient and next steps, and the receipt link for every call."}]}
    )
    print(result["messages"][-1].content)

asyncio.run(main())
```

## Bring your own client

```python
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain_zambo import server_config

client = MultiServerMCPClient({**server_config()})  # add your own servers too
```

## Notes

- Endpoint: `https://zambo.dev/mcp` (plain JSON-RPC over HTTPS, `streamable_http` transport, no auth).
- Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free. Day Pass $0.99, unlimited for 24 hours at [zambo.dev/day-pass](https://zambo.dev/day-pass/).
- Every tool call returns a verifiable receipt: proof the saved result was not changed, so the record of what the agent did can be checked by anyone.
- No GitHub, no extra services: this package, `langchain-mcp-adapters`, and zambo.dev are the whole stack.

## Where these receipts run live: Zambo

langchain-zambo turns Zambo's MCP tools into LangChain StructuredTools with a verifiable AER-1 receipt for every call, and it has been downloaded 4,129 times on PyPI. The live home of those receipts is Zambo, the verifiable work layer for AI. Connect any AI to the live endpoint at https://zambo.dev/mcp or add Zambo to your AI in one step at https://zambo.dev/add/

Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free. The Day Pass is $0.99 for 24 hours, unlimited. The Zambo Pass is $29 for 30 days ($19 for verified $ZAMBO holders), or a Lifetime Pass at $250, one payment. Full pricing: https://zambo.dev/pricing

Install:

    pip install langchain-zambo

Zambo, built by Brennan Zambo, the creator of the AER-1 standard, runs 153 tools in total, 37 on the default surface, behind one MCP endpoint: https://zambo.dev/mcp.

**Verify any receipt free:** paste a receipt id at [zambo.dev/verify/](https://zambo.dev/verify/) and recompute it. Verification is always free.
