forgemcp

# ForgeMCP

> **Give your AI agents production-ready tools — without building them yourself.**

ForgeMCP is managed MCP (Model Context Protocol) infrastructure. Instead of spending days building web search, code execution, and data storage into your AI agent, connect to ForgeMCP in minutes.

```bash
# Register → Get API key → Connect your agent
# That's it.
```

## Contents

- [Quick Start](#quick-start) — Get running in 2 minutes
- [Tools](#tools-included) — All available MCP tools
- [SDKs & Examples](#sdks--examples) — Node.js, Python, CLI
- [Framework Integrations](#connect-to-claude-code) — Claude Code, LangChain, CrewAI
- [Pricing](#pricing) — Free tier, Pro, Enterprise

## What it does

When your AI agent needs to do something in the real world — search the web, run code, store data, track events — it calls ForgeMCP instead of you building it. We handle the infrastructure, reliability, rate limits, and billing.

## Tools included

| Tool | What it does | Cost |
|------|-------------|------|
| `web_search` | Real-time web search with answers | $0.001/req |
| `url_fetch` | Fetch + extract readable content from any URL | Free |
| `code_execute` | Sandboxed JavaScript execution | $0.01/call |
| `data_store` | Per-agent key-value storage | Free |
| `analytics_track` | Event tracking + queries | Free |
| `weather` | Current weather for any location | Free |

## Quick start

```bash
# 1. Get an API key (free tier: 1,000 requests/month)
curl -X POST https://api.forgemcp.com/v1/auth/register \
  -H "Content-Type: application/json" \
  -d '{"email": "you@example.com", "password": "yourpass123"}'

# 2. List available tools
curl https://api.forgemcp.com/v1/tools \
  -H "Authorization: Bearer bk_forge_..."

# 3. Execute a tool
curl -X POST https://api.forgemcp.com/v1/tools/weather/execute \
  -H "Authorization: Bearer bk_forge_..." \
  -H "Content-Type: application/json" \
  -d '{"location": "Minneapolis"}'
```

## Connect to Claude Code

Add to your Claude Code `mcp.json`:

```json
{
  "mcpServers": {
    "ForgeMCP": {
      "url": "https://api.forgemcp.com/v1/mcp",
      "headers": {
        "Authorization": "Bearer bk_forge_your_key"
      }
    }
  }
}
```

[Full Claude Code setup →](docs/setup-claude-code.md)

## Connect to LangChain

```python
from langchain.tools import Tool
from langchain.agents import initialize_agent

def forgerpc_call(tool_name: str, params: dict):
    import requests
    resp = requests.post(
        f"https://api.forgemcp.com/v1/tools/{tool_name}/execute",
        headers={"Authorization": "Bearer bk_forge_your_key"},
        json={"params": params}
    )
    return resp.json()["result"]["data"]

tools = [
    Tool(
        name="WebSearch",
        func=lambda q: forgerpc_call("web_search", {"query": q}),
        description="Search the web for current information"
    ),
    Tool(
        name="CodeExecute",
        func=lambda code: forgerpc_call("code_execute", {"code": code}),
        description="Execute JavaScript code"
    ),
]
```

## Connect to CrewAI

```python
from crewai.tools import BaseTool
from pydantic import Field

class ForgeMCPTool(BaseTool):
    name: str = "ForgeMCP Tool"
    description: str = "Call a ForgeMCP tool"
    tool_name: str = Field(..., description="Name of the tool to call")

    def _run(self, **kwargs):
        import requests
        resp = requests.post(
            f"https://api.forgemcp.com/v1/tools/{self.tool_name}/execute",
            headers={"Authorization": "Bearer bk_forge_your_key"},
            json={"params": kwargs}
        ).json()
        return resp["result"]["data"]

# Usage
search_tool = ForgeMCPTool(tool_name="web_search")
```

## SDKs & Examples

**Node.js SDK:**
```bash
npm install @forgemcp/sdk
```
```javascript
import ForgeMCP from '@forgemcp/sdk';

const forge = new ForgeMCP({ apiKey: 'bk_forge_...' });
const { data } = await forge.web_search({ query: 'AI agents 2026' });
```
Full example: [`examples/node/example.mjs`](examples/node/example.mjs)

**Python SDK:**
```bash
pip install forgemcp
```
```python
from forgemcp import ForgeMCP
forge = ForgeMCP(api_key='bk_forge_...')
result = forge.web_search(query='AI agents 2026')
```
Full example: [`python/`](python/)

**CLI:**
```bash
npx forgemcp register --email=you@example.com --password=xxx
npx forgemcp tools
npx forgemcp usage
```

Full CLI docs: [`cli/forgemcp.js`](cli/forgemcp.js)

## Pricing

| Tier | Price | Requests/mo | Tools | Rate limit |
|------|-------|-------------|-------|-----------|
| **Free** | $0 | 1,000 | 5 core | 10/min |
| **Pro** | $19/mo | 50,000 | All + search | 100/min |
| **Enterprise** | $99/mo | 500,000 | All + custom | 500/min |

[See full pricing →](https://forgemcp.com/#pricing)

## Why ForgeMCP?

**Built for agents, not humans.** Every tool is designed for programmatic calls from an AI agent — not a developer dashboard. JSON-RPC 2.0 protocol, structured responses, consistent error handling.

**Zero infrastructure to manage.** No servers to provision, no APIs to integrate, no uptime to monitor. Your agent calls ForgeMCP, ForgeMCP handles the rest.

**Usage-based pricing that makes sense.** Free tier is actually usable. Pro is $19/month for 50K requests — about $0.0004 per request. Enterprise for teams running heavy workloads.

**Works with every agent framework.** Claude Code, LangChain, CrewAI, AutoGen, OpenAI Agents SDK. If it speaks MCP or HTTP, it works with ForgeMCP.

## MCP Manifest

The complete tool specification is in [`mcp.json`](mcp.json) — this is what MCP-compatible agents use to discover and validate ForgeMCP tools.

```json
{
  "name": "ForgeMCP",
  "version": "1.0.0",
  "baseUrl": "https://api.forgemcp.com/v1",
  "tools": [...]
}
```

Add this URL to your MCP client configuration: `https://api.forgemcp.com/v1/mcp`

## Status

- ✅ All tools operational
- ✅ JSON-RPC 2.0 protocol
- ✅ Stripe billing (Pro/Enterprise)
- 🔄 GitHub Actions CI/CD

## License

MIT