bonito-mcp 1.0.0__tar.gz

bonito_mcp-1.0.0/.env.example

@@ -0,0 +1,8 @@
+# Bonito MCP Server Configuration
+# Copy this file to .env and fill in your values.
+
+# Required: Your Bonito API / gateway key
+BONITO_API_KEY=YOUR_KEY_HERE
+
+# Optional: Override the API base URL (defaults to https://api.getbonito.com)
+# BONITO_API_URL=https://api.getbonito.com

bonito_mcp-1.0.0/.gitignore

@@ -0,0 +1,12 @@
+node_modules/
+.next/
+__pycache__/
+*.pyc
+.env
+.venv/
+dist/
+*.egg-info/
+.env.secrets
+secrets/age-key.txt
+secrets/*.yaml
+!secrets/*.enc.yaml

bonito_mcp-1.0.0/Dockerfile

@@ -0,0 +1,6 @@
+FROM python:3.11-slim
+WORKDIR /app
+COPY . .
+RUN pip install --no-cache-dir -e .
+EXPOSE 8080
+CMD ["bonito-mcp", "--transport", "sse", "--port", "8080"]

bonito_mcp-1.0.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: bonito-mcp
+Version: 1.0.0
+Summary: MCP server for the Bonito AI Platform – manage providers, models, agents, and gateway routing.
+Project-URL: Homepage, https://getbonito.com
+Project-URL: Documentation, https://getbonito.com/docs
+Project-URL: Repository, https://github.com/ShabariRepo/bonito
+Author-email: Bonito AI <hello@getbonito.com>
+License-Expression: MIT
+Keywords: ai,bonito,gateway,llm,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: mcp>=1.0.0
+Description-Content-Type: text/markdown
+
+# Bonito MCP Server
+
+A [Model Context Protocol (MCP)](https://modelcontextprotocol.io) server that wraps the **Bonito AI Platform** REST API. Use it from Claude Desktop, Cursor, or any MCP-compatible client to manage your multi-provider AI infrastructure.
+
+## Features
+
+- **Provider Management** – Connect and verify AWS Bedrock, Azure OpenAI, GCP Vertex AI, OpenAI, Anthropic, and Groq
+- **Model Management** – List, sync, and activate models across providers
+- **Unified Gateway** – Send chat completions through Bonito's OpenAI-compatible gateway
+- **Agent Management** – Create and execute BonBon and Bonobot agents
+- **Knowledge Bases** – Create and manage knowledge bases
+- **Cost & Observability** – Track costs per provider and view gateway logs
+
+## Quick Start
+
+### Install from source
+
+```bash
+git clone https://github.com/ShabariRepo/bonito.git
+cd bonito/mcp-server
+pip install -e .
+```
+
+### Set your API key
+
+```bash
+export BONITO_API_KEY="your-bonito-api-key"
+```
+
+### Run (stdio – for Claude Desktop)
+
+```bash
+bonito-mcp
+```
+
+### Run (SSE – for network clients)
+
+```bash
+bonito-mcp --transport sse --port 8080
+```
+
+## Claude Desktop Configuration
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "bonito": {
+      "command": "bonito-mcp",
+      "env": {
+        "BONITO_API_KEY": "your-bonito-api-key"
+      }
+    }
+  }
+}
+```
+
+## Docker
+
+```bash
+docker build -t bonito-mcp .
+docker run -e BONITO_API_KEY="your-key" -p 8080:8080 bonito-mcp
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_providers` | List connected AI providers |
+| `connect_provider` | Connect a new provider |
+| `verify_provider` | Verify provider credentials |
+| `list_models` | List models (with filters) |
+| `sync_models` | Sync models from providers |
+| `activate_model` | Activate a model for the gateway |
+| `chat_completion` | Send a chat completion request |
+| `list_gateway_keys` | List gateway API keys |
+| `create_gateway_key` | Create a new gateway key |
+| `gateway_usage` | View usage statistics |
+| `list_agents` | List agents in a project |
+| `create_agent` | Create a BonBon or Bonobot agent |
+| `execute_agent` | Execute an agent |
+| `get_agent` | Get agent details |
+| `list_knowledge_bases` | List knowledge bases |
+| `create_knowledge_base` | Create a knowledge base |
+| `get_costs` | Get cost breakdown by provider |
+| `get_gateway_logs` | View gateway request logs |
+
+## Environment Variables
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `BONITO_API_KEY` | Yes | – | Your Bonito API key |
+| `BONITO_API_URL` | No | `https://api.getbonito.com` | API base URL |
+
+## License
+
+MIT

bonito_mcp-1.0.0/README.md

@@ -0,0 +1,98 @@
+# Bonito MCP Server
+
+A [Model Context Protocol (MCP)](https://modelcontextprotocol.io) server that wraps the **Bonito AI Platform** REST API. Use it from Claude Desktop, Cursor, or any MCP-compatible client to manage your multi-provider AI infrastructure.
+
+## Features
+
+- **Provider Management** – Connect and verify AWS Bedrock, Azure OpenAI, GCP Vertex AI, OpenAI, Anthropic, and Groq
+- **Model Management** – List, sync, and activate models across providers
+- **Unified Gateway** – Send chat completions through Bonito's OpenAI-compatible gateway
+- **Agent Management** – Create and execute BonBon and Bonobot agents
+- **Knowledge Bases** – Create and manage knowledge bases
+- **Cost & Observability** – Track costs per provider and view gateway logs
+
+## Quick Start
+
+### Install from source
+
+```bash
+git clone https://github.com/ShabariRepo/bonito.git
+cd bonito/mcp-server
+pip install -e .
+```
+
+### Set your API key
+
+```bash
+export BONITO_API_KEY="your-bonito-api-key"
+```
+
+### Run (stdio – for Claude Desktop)
+
+```bash
+bonito-mcp
+```
+
+### Run (SSE – for network clients)
+
+```bash
+bonito-mcp --transport sse --port 8080
+```
+
+## Claude Desktop Configuration
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "bonito": {
+      "command": "bonito-mcp",
+      "env": {
+        "BONITO_API_KEY": "your-bonito-api-key"
+      }
+    }
+  }
+}
+```
+
+## Docker
+
+```bash
+docker build -t bonito-mcp .
+docker run -e BONITO_API_KEY="your-key" -p 8080:8080 bonito-mcp
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_providers` | List connected AI providers |
+| `connect_provider` | Connect a new provider |
+| `verify_provider` | Verify provider credentials |
+| `list_models` | List models (with filters) |
+| `sync_models` | Sync models from providers |
+| `activate_model` | Activate a model for the gateway |
+| `chat_completion` | Send a chat completion request |
+| `list_gateway_keys` | List gateway API keys |
+| `create_gateway_key` | Create a new gateway key |
+| `gateway_usage` | View usage statistics |
+| `list_agents` | List agents in a project |
+| `create_agent` | Create a BonBon or Bonobot agent |
+| `execute_agent` | Execute an agent |
+| `get_agent` | Get agent details |
+| `list_knowledge_bases` | List knowledge bases |
+| `create_knowledge_base` | Create a knowledge base |
+| `get_costs` | Get cost breakdown by provider |
+| `get_gateway_logs` | View gateway request logs |
+
+## Environment Variables
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `BONITO_API_KEY` | Yes | – | Your Bonito API key |
+| `BONITO_API_URL` | No | `https://api.getbonito.com` | API base URL |
+
+## License
+
+MIT

bonito_mcp-1.0.0/bonito_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""Bonito MCP Server - Model Context Protocol server for the Bonito AI Platform."""
+
+__version__ = "1.0.0"

bonito_mcp-1.0.0/bonito_mcp/client.py

@@ -0,0 +1,173 @@
+"""HTTP client wrapper for the Bonito REST API."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+
+
+class BonitoClient:
+    """Async HTTP client for Bonito API calls."""
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        api_key: str | None = None,
+    ) -> None:
+        self.base_url = (base_url or os.environ.get("BONITO_API_URL", "https://api.getbonito.com")).rstrip("/")
+        self.api_key = api_key or os.environ.get("BONITO_API_KEY", "")
+        if not self.api_key:
+            raise ValueError(
+                "BONITO_API_KEY is required. Set it as an environment variable or pass it directly."
+            )
+        self._client: httpx.AsyncClient | None = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json",
+                },
+                timeout=httpx.Timeout(30.0),
+            )
+        return self._client
+
+    async def close(self) -> None:
+        if self._client and not self._client.is_closed:
+            await self._client.aclose()
+
+    # ── Generic request helpers ──────────────────────────────────────
+
+    async def get(self, path: str, params: dict[str, Any] | None = None) -> Any:
+        client = await self._get_client()
+        resp = await client.get(path, params=params)
+        resp.raise_for_status()
+        return resp.json()
+
+    async def post(self, path: str, json: dict[str, Any] | None = None) -> Any:
+        client = await self._get_client()
+        resp = await client.post(path, json=json)
+        resp.raise_for_status()
+        return resp.json()
+
+    async def put(self, path: str, json: dict[str, Any] | None = None) -> Any:
+        client = await self._get_client()
+        resp = await client.put(path, json=json)
+        resp.raise_for_status()
+        return resp.json()
+
+    async def delete(self, path: str) -> Any:
+        client = await self._get_client()
+        resp = await client.delete(path)
+        resp.raise_for_status()
+        return resp.json()
+
+    # ── Provider Management ──────────────────────────────────────────
+
+    async def list_providers(self) -> Any:
+        return await self.get("/api/providers")
+
+    async def connect_provider(self, provider_type: str, credentials: dict[str, Any]) -> Any:
+        return await self.post("/api/providers/connect", json={
+            "provider_type": provider_type,
+            "credentials": credentials,
+        })
+
+    async def verify_provider(self, provider_id: str) -> Any:
+        return await self.post(f"/api/providers/{provider_id}/verify")
+
+    # ── Model Management ─────────────────────────────────────────────
+
+    async def list_models(
+        self,
+        provider: str | None = None,
+        capability: str | None = None,
+        active: bool | None = None,
+    ) -> Any:
+        params: dict[str, Any] = {}
+        if provider:
+            params["provider"] = provider
+        if capability:
+            params["capability"] = capability
+        if active is not None:
+            params["active"] = str(active).lower()
+        return await self.get("/api/models", params=params or None)
+
+    async def sync_models(self) -> Any:
+        return await self.post("/api/models/sync")
+
+    async def activate_model(self, model_id: str) -> Any:
+        return await self.post(f"/api/models/{model_id}/activate")
+
+    # ── Gateway ──────────────────────────────────────────────────────
+
+    async def chat_completion(self, model: str, messages: list[dict[str, str]], **kwargs: Any) -> Any:
+        payload: dict[str, Any] = {"model": model, "messages": messages, **kwargs}
+        return await self.post("/v1/chat/completions", json=payload)
+
+    async def list_gateway_keys(self) -> Any:
+        return await self.get("/api/gateway/keys")
+
+    async def create_gateway_key(self, name: str | None = None) -> Any:
+        payload: dict[str, Any] = {}
+        if name:
+            payload["name"] = name
+        return await self.post("/api/gateway/keys", json=payload)
+
+    async def gateway_usage(self, period: str | None = None) -> Any:
+        params: dict[str, Any] = {}
+        if period:
+            params["period"] = period
+        return await self.get("/api/gateway/usage", params=params or None)
+
+    # ── Agent Management ─────────────────────────────────────────────
+
+    async def list_agents(self, project_id: str) -> Any:
+        return await self.get(f"/api/projects/{project_id}/agents")
+
+    async def create_agent(self, project_id: str, agent_config: dict[str, Any]) -> Any:
+        return await self.post(f"/api/projects/{project_id}/agents", json=agent_config)
+
+    async def execute_agent(self, agent_id: str, message: str) -> Any:
+        return await self.post(f"/api/agents/{agent_id}/execute", json={"message": message})
+
+    async def get_agent(self, agent_id: str) -> Any:
+        return await self.get(f"/api/agents/{agent_id}")
+
+    # ── Knowledge Bases ──────────────────────────────────────────────
+
+    async def list_knowledge_bases(self) -> Any:
+        return await self.get("/api/knowledge-bases")
+
+    async def create_knowledge_base(self, name: str, description: str | None = None) -> Any:
+        payload: dict[str, Any] = {"name": name}
+        if description:
+            payload["description"] = description
+        return await self.post("/api/knowledge-bases", json=payload)
+
+    # ── Cost & Observability ─────────────────────────────────────────
+
+    async def get_costs(self, provider_id: str, period: str | None = None) -> Any:
+        params: dict[str, Any] = {}
+        if period:
+            params["period"] = period
+        return await self.get(f"/api/providers/{provider_id}/costs", params=params or None)
+
+    async def get_gateway_logs(
+        self,
+        limit: int | None = None,
+        offset: int | None = None,
+        model: str | None = None,
+    ) -> Any:
+        params: dict[str, Any] = {}
+        if limit is not None:
+            params["limit"] = limit
+        if offset is not None:
+            params["offset"] = offset
+        if model:
+            params["model"] = model
+        return await self.get("/api/gateway/logs", params=params or None)

bonito_mcp-1.0.0/bonito_mcp/server.py

@@ -0,0 +1,356 @@
+"""Bonito MCP Server – exposes the Bonito AI Platform REST API as MCP tools."""
+
+from __future__ import annotations
+
+import json
+import sys
+from contextlib import asynccontextmanager
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from bonito_mcp.client import BonitoClient
+
+# ── Lifespan: initialise / tear-down the HTTP client ─────────────────
+
+
+@asynccontextmanager
+async def lifespan(server: FastMCP):
+    """Create a shared BonitoClient for the server's lifetime."""
+    client = BonitoClient()
+    try:
+        yield {"client": client}
+    finally:
+        await client.close()
+
+
+# ── Server instance ──────────────────────────────────────────────────
+
+app = FastMCP(
+    "Bonito",
+    instructions=(
+        "Bonito MCP Server – manage multi-provider AI infrastructure. "
+        "Connect cloud AI providers, deploy agents, route requests through "
+        "the unified gateway, and monitor costs."
+    ),
+    lifespan=lifespan,
+)
+
+
+def _client(ctx) -> BonitoClient:
+    """Retrieve the BonitoClient from the lifespan context."""
+    return ctx.request_context.lifespan_context["client"]
+
+
+def _json(data: Any) -> str:
+    """Pretty-print JSON for tool responses."""
+    return json.dumps(data, indent=2, default=str)
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# Provider Management
+# ═══════════════════════════════════════════════════════════════════════
+
+
+@app.tool()
+async def list_providers(ctx) -> str:
+    """List all connected AI providers (AWS Bedrock, Azure OpenAI, GCP Vertex, OpenAI, Anthropic, Groq)."""
+    result = await _client(ctx).list_providers()
+    return _json(result)
+
+
+@app.tool()
+async def connect_provider(
+    provider_type: str,
+    credentials: str,
+    ctx=None,
+) -> str:
+    """Connect a new AI provider.
+
+    Args:
+        provider_type: Provider type – one of: aws_bedrock, azure_openai, gcp_vertex, openai, anthropic, groq
+        credentials: JSON string with provider-specific credentials (e.g. API keys, region, project ID)
+    """
+    creds = json.loads(credentials) if isinstance(credentials, str) else credentials
+    result = await _client(ctx).connect_provider(provider_type, creds)
+    return _json(result)
+
+
+@app.tool()
+async def verify_provider(provider_id: str, ctx=None) -> str:
+    """Verify connectivity and credentials for a connected provider.
+
+    Args:
+        provider_id: The provider ID to verify
+    """
+    result = await _client(ctx).verify_provider(provider_id)
+    return _json(result)
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# Model Management
+# ═══════════════════════════════════════════════════════════════════════
+
+
+@app.tool()
+async def list_models(
+    provider: str | None = None,
+    capability: str | None = None,
+    active: bool | None = None,
+    ctx=None,
+) -> str:
+    """List available models across all providers with optional filters.
+
+    Args:
+        provider: Filter by provider (e.g. openai, anthropic, aws_bedrock)
+        capability: Filter by capability (e.g. chat, embedding, image)
+        active: Filter by activation status
+    """
+    result = await _client(ctx).list_models(provider=provider, capability=capability, active=active)
+    return _json(result)
+
+
+@app.tool()
+async def sync_models(ctx) -> str:
+    """Sync available models from all connected providers. Discovers newly available models."""
+    result = await _client(ctx).sync_models()
+    return _json(result)
+
+
+@app.tool()
+async def activate_model(model_id: str, ctx=None) -> str:
+    """Activate a model to make it available through the gateway.
+
+    Args:
+        model_id: The model ID to activate
+    """
+    result = await _client(ctx).activate_model(model_id)
+    return _json(result)
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# Gateway
+# ═══════════════════════════════════════════════════════════════════════
+
+
+@app.tool()
+async def chat_completion(
+    model: str,
+    messages: str,
+    temperature: float | None = None,
+    max_tokens: int | None = None,
+    ctx=None,
+) -> str:
+    """Send a chat completion request through the Bonito gateway (OpenAI-compatible).
+
+    Args:
+        model: Model identifier (e.g. gpt-4o, claude-sonnet-4-20250514, or a Bonito model alias)
+        messages: JSON array of message objects, e.g. [{"role":"user","content":"Hello"}]
+        temperature: Sampling temperature (0-2)
+        max_tokens: Maximum tokens to generate
+    """
+    msgs = json.loads(messages) if isinstance(messages, str) else messages
+    kwargs: dict[str, Any] = {}
+    if temperature is not None:
+        kwargs["temperature"] = temperature
+    if max_tokens is not None:
+        kwargs["max_tokens"] = max_tokens
+    result = await _client(ctx).chat_completion(model, msgs, **kwargs)
+    return _json(result)
+
+
+@app.tool()
+async def list_gateway_keys(ctx) -> str:
+    """List all API keys for the Bonito gateway."""
+    result = await _client(ctx).list_gateway_keys()
+    return _json(result)
+
+
+@app.tool()
+async def create_gateway_key(name: str | None = None, ctx=None) -> str:
+    """Create a new gateway API key.
+
+    Args:
+        name: Optional friendly name for the key
+    """
+    result = await _client(ctx).create_gateway_key(name=name)
+    return _json(result)
+
+
+@app.tool()
+async def gateway_usage(period: str | None = None, ctx=None) -> str:
+    """Get gateway usage statistics.
+
+    Args:
+        period: Time period – e.g. 24h, 7d, 30d
+    """
+    result = await _client(ctx).gateway_usage(period=period)
+    return _json(result)
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# Agent Management
+# ═══════════════════════════════════════════════════════════════════════
+
+
+@app.tool()
+async def list_agents(project_id: str, ctx=None) -> str:
+    """List all agents in a project.
+
+    Args:
+        project_id: The project ID
+    """
+    result = await _client(ctx).list_agents(project_id)
+    return _json(result)
+
+
+@app.tool()
+async def create_agent(
+    project_id: str,
+    name: str,
+    model: str,
+    system_prompt: str | None = None,
+    agent_type: str = "bonbon",
+    ctx=None,
+) -> str:
+    """Create a new agent (BonBon or Bonobot).
+
+    Args:
+        project_id: The project ID to create the agent in
+        name: Agent name
+        model: Model to use (e.g. gpt-4o, claude-sonnet-4-20250514)
+        system_prompt: Optional system prompt for the agent
+        agent_type: Agent type – bonbon (single model) or bonobot (multi-model orchestrator)
+    """
+    config: dict[str, Any] = {
+        "name": name,
+        "model": model,
+        "type": agent_type,
+    }
+    if system_prompt:
+        config["system_prompt"] = system_prompt
+    result = await _client(ctx).create_agent(project_id, config)
+    return _json(result)
+
+
+@app.tool()
+async def execute_agent(agent_id: str, message: str, ctx=None) -> str:
+    """Execute an agent with a message.
+
+    Args:
+        agent_id: The agent ID to execute
+        message: The message to send to the agent
+    """
+    result = await _client(ctx).execute_agent(agent_id, message)
+    return _json(result)
+
+
+@app.tool()
+async def get_agent(agent_id: str, ctx=None) -> str:
+    """Get details of a specific agent.
+
+    Args:
+        agent_id: The agent ID
+    """
+    result = await _client(ctx).get_agent(agent_id)
+    return _json(result)
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# Knowledge Bases
+# ═══════════════════════════════════════════════════════════════════════
+
+
+@app.tool()
+async def list_knowledge_bases(ctx) -> str:
+    """List all knowledge bases."""
+    result = await _client(ctx).list_knowledge_bases()
+    return _json(result)
+
+
+@app.tool()
+async def create_knowledge_base(name: str, description: str | None = None, ctx=None) -> str:
+    """Create a new knowledge base.
+
+    Args:
+        name: Name for the knowledge base
+        description: Optional description
+    """
+    result = await _client(ctx).create_knowledge_base(name, description=description)
+    return _json(result)
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# Cost & Observability
+# ═══════════════════════════════════════════════════════════════════════
+
+
+@app.tool()
+async def get_costs(provider_id: str, period: str | None = None, ctx=None) -> str:
+    """Get cost breakdown for a specific provider.
+
+    Args:
+        provider_id: The provider ID
+        period: Time period – e.g. 24h, 7d, 30d
+    """
+    result = await _client(ctx).get_costs(provider_id, period=period)
+    return _json(result)
+
+
+@app.tool()
+async def get_gateway_logs(
+    limit: int | None = None,
+    offset: int | None = None,
+    model: str | None = None,
+    ctx=None,
+) -> str:
+    """Get gateway request logs for observability.
+
+    Args:
+        limit: Maximum number of log entries to return
+        offset: Offset for pagination
+        model: Filter logs by model name
+    """
+    result = await _client(ctx).get_gateway_logs(limit=limit, offset=offset, model=model)
+    return _json(result)
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# CLI entry point
+# ═══════════════════════════════════════════════════════════════════════
+
+
+def main() -> None:
+    """Run the Bonito MCP server."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Bonito MCP Server")
+    parser.add_argument(
+        "--transport",
+        choices=["stdio", "sse"],
+        default="stdio",
+        help="Transport type (default: stdio)",
+    )
+    parser.add_argument(
+        "--host",
+        default="127.0.0.1",
+        help="Host for SSE transport (default: 127.0.0.1)",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8080,
+        help="Port for SSE transport (default: 8080)",
+    )
+    args = parser.parse_args()
+
+    if args.transport == "sse":
+        app.settings.host = args.host
+        app.settings.port = args.port
+        app.run(transport="sse")
+    else:
+        app.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

bonito_mcp-1.0.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "bonito-mcp"
+version = "1.0.0"
+description = "MCP server for the Bonito AI Platform – manage providers, models, agents, and gateway routing."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Bonito AI", email = "hello@getbonito.com" },
+]
+keywords = ["mcp", "bonito", "ai", "llm", "gateway"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "mcp>=1.0.0",
+    "httpx>=0.25.0",
+]
+
+[project.scripts]
+bonito-mcp = "bonito_mcp.server:main"
+
+[project.urls]
+Homepage = "https://getbonito.com"
+Documentation = "https://getbonito.com/docs"
+Repository = "https://github.com/ShabariRepo/bonito"