mbxai 0.1.0__py3-none-any.whl

mbxai/__init__.py

@@ -0,0 +1,5 @@
+"""
+MBX AI package.
+"""
+
+__version__ = "0.1.0" 

mbxai/core.py

@@ -0,0 +1,12 @@
+"""
+Core functionality for MBX AI.
+"""
+
+def hello_world() -> str:
+    """
+    Returns a greeting message.
+    
+    Returns:
+        str: A greeting message
+    """
+    return "Hello from MBX AI!" 

mbxai/mcp/__init__.py

@@ -0,0 +1,6 @@
+"""Model Context Protocol (MCP) implementation for MBX AI."""
+
+from .client import MCPClient
+from .server import MCPServer, Tool
+
+__all__ = ["MCPClient", "MCPServer", "Tool"] 

mbxai/mcp/client.py

@@ -0,0 +1,116 @@
+"""MCP client implementation."""
+
+from typing import Any, TypeVar, Callable
+import httpx
+from pydantic import BaseModel, Field
+
+from ..tools import ToolClient, Tool
+from ..openrouter import OpenRouterClient
+
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class MCPTool(Tool):
+    """MCP tool definition."""
+    internal_url: str | None = Field(default=None, description="The internal URL to invoke the tool")
+    service: str = Field(description="The service that provides the tool")
+    strict: bool = Field(default=True, description="Whether the tool response is strictly validated")
+    input_schema: dict[str, Any] = Field(description="The input schema for the tool")
+
+    def to_openai_function(self) -> dict[str, Any]:
+        """Convert the tool to an OpenAI function definition."""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "parameters": self._convert_to_openai_schema(self.input_schema)
+        }
+
+    def _convert_to_openai_schema(self, mcp_schema: dict[str, Any]) -> dict[str, Any]:
+        """Convert MCP schema to OpenAI schema format."""
+        if not mcp_schema:
+            return {"type": "object", "properties": {}}
+
+        # If schema has a $ref, resolve it
+        if "$ref" in mcp_schema:
+            ref = mcp_schema["$ref"].split("/")[-1]
+            mcp_schema = mcp_schema.get("$defs", {}).get(ref, {})
+
+        # If schema has an input wrapper, unwrap it
+        if "properties" in mcp_schema and "input" in mcp_schema["properties"]:
+            input_schema = mcp_schema["properties"]["input"]
+            if "$ref" in input_schema:
+                ref = input_schema["$ref"].split("/")[-1]
+                input_schema = mcp_schema.get("$defs", {}).get(ref, {})
+            return input_schema
+
+        return mcp_schema
+
+
+class MCPClient(ToolClient):
+    """MCP client that extends ToolClient to support MCP tool servers."""
+
+    def __init__(self, openrouter_client: OpenRouterClient):
+        """Initialize the MCP client."""
+        super().__init__(openrouter_client)
+        self._mcp_servers: dict[str, str] = {}
+        self._http_client = httpx.AsyncClient()
+
+    async def __aenter__(self):
+        """Enter the async context."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Exit the async context."""
+        await self._http_client.aclose()
+
+    def _create_tool_function(self, tool: MCPTool) -> Callable[..., Any]:
+        """Create a function that invokes an MCP tool."""
+        async def tool_function(**kwargs: Any) -> Any:
+            # If kwargs has input wrapper, unwrap it
+            if "input" in kwargs:
+                kwargs = kwargs["input"]
+
+            # Get the URL to use for the tool
+            url = tool.internal_url
+            if url is None:
+                # Use the MCP server URL as fallback
+                server_url = self._mcp_servers.get(tool.service)
+                if server_url is None:
+                    raise ValueError(f"No MCP server found for service {tool.service}")
+                url = f"{server_url}/tools/{tool.name}/invoke"
+
+            # Make the HTTP request to the tool's URL
+            response = await self._http_client.post(
+                url,
+                json={"input": kwargs} if tool.strict else kwargs
+            )
+            return response.json()
+        
+        # Create a sync wrapper for the async function
+        def sync_tool_function(**kwargs: Any) -> Any:
+            import asyncio
+            loop = asyncio.get_event_loop()
+            return loop.run_until_complete(tool_function(**kwargs))
+        
+        return sync_tool_function
+
+    async def register_mcp_server(self, name: str, base_url: str) -> None:
+        """Register an MCP server and load its tools."""
+        self._mcp_servers[name] = base_url.rstrip("/")
+        
+        # Fetch tools from the server
+        response = await self._http_client.get(f"{base_url}/tools")
+        tools_data = response.json()
+        
+        # Register each tool
+        for tool_data in tools_data:
+            # Create MCPTool instance
+            tool = MCPTool(**tool_data)
+            
+            # Create the tool function
+            tool_function = self._create_tool_function(tool)
+            
+            # Register the tool with ToolClient
+            self._tools[tool.name] = tool
+            tool.function = tool_function 

mbxai/mcp/example.py

@@ -0,0 +1,84 @@
+"""Example usage of MCP client and server."""
+
+import asyncio
+from typing import Any
+from pydantic import BaseModel
+from mcp.server.fastmcp import FastMCP
+
+from ..openrouter import OpenRouterClient
+from .client import MCPClient
+from .server import MCPServer
+
+
+# Create a FastMCP instance for this module
+mcp = FastMCP("weather-service")
+
+
+# Define input/output models
+class WeatherInput(BaseModel):
+    location: str
+    units: str = "celsius"  # Default to celsius, can be "fahrenheit" or "celsius"
+
+
+class WeatherOutput(BaseModel):
+    location: str
+    temperature: float
+    units: str
+    condition: str
+    humidity: float
+
+
+@mcp.tool()
+async def get_weather(input: WeatherInput) -> dict[str, Any]:
+    """Get weather information for a location.
+    
+    Args:
+        input: WeatherInput model containing location and units preference
+    """
+    # This is a mock implementation
+    temperature = 20 if input.units == "celsius" else 68  # Convert to fahrenheit if needed
+    
+    return {
+        "location": input.location,
+        "temperature": temperature,
+        "units": input.units,
+        "condition": "sunny",
+        "humidity": 65,
+    }
+
+
+async def main():
+    # Create and start the MCP server
+    server = MCPServer("weather-service")
+    
+    # Register the tool with the MCP server
+    server.mcp_server.add_tool(get_weather)
+    
+    # Create the OpenRouter client
+    openrouter_client = OpenRouterClient(token="your-api-key")
+    
+    # Create the MCP client
+    mcp_client = MCPClient(openrouter_client)
+    
+    # Register the MCP server
+    await mcp_client.register_mcp_server(
+        name="weather-service",
+        base_url="http://localhost:8000"
+    )
+    
+    # Use the tool in a chat
+    messages = [{"role": "user", "content": "What's the weather like in New York?"}]
+    response = await mcp_client.chat(messages)
+    print(response.choices[0].message.content)
+    
+    # Use the tool with structured output
+    response = await mcp_client.parse(messages, WeatherOutput)
+    weather_info = response.choices[0].message.parsed
+    print(f"Location: {weather_info.location}")
+    print(f"Temperature: {weather_info.temperature}°{weather_info.units.upper()}")
+    print(f"Condition: {weather_info.condition}")
+    print(f"Humidity: {weather_info.humidity}%")
+
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

mbxai/mcp/server.py

@@ -0,0 +1,92 @@
+"""MCP server implementation."""
+
+from typing import Any, Callable, TypeVar
+from fastapi import FastAPI, Body
+from mcp.server.fastmcp import FastMCP
+from pydantic import BaseModel, Field, ConfigDict
+
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class Tool(BaseModel):
+    """MCP tool definition."""
+    model_config = ConfigDict(strict=True)
+    name: str = Field(description="The name of the tool")
+    description: str = Field(description="The description of what the tool does")
+    input_schema: dict[str, Any] = Field(description="The input schema for the tool")
+    strict: bool = Field(default=True, description="Whether the tool response is strictly validated")
+    function: Callable[..., Any] = Field(description="The tool function", exclude=True)
+
+
+class MCPServer:
+    """MCP server implementation."""
+
+    def __init__(self, name: str, description: str | None = None):
+        """Initialize the MCP server."""
+        self.name = name
+        self.description = description or f"A Model Context Protocol (MCP) tool server for {name}"
+        
+        # Create FastAPI app
+        self.app = FastAPI(
+            title=self.name,
+            description=self.description,
+            version="0.1.0",
+        )
+        
+        # Initialize MCP server
+        self.mcp_server = FastMCP(self.name)
+        
+        # Register endpoints
+        self._register_endpoints()
+        
+        # Store registered tools
+        self._tools: dict[str, Tool] = {}
+
+    def _register_endpoints(self) -> None:
+        """Register FastAPI endpoints."""
+        @self.app.get("/tools", response_model=list[Tool])
+        async def get_tools():
+            """Get all available MCP tools."""
+            return list(self._tools.values())
+
+        @self.app.post("/tools/{tool_name}/invoke")
+        async def invoke_tool(tool_name: str, arguments: dict[str, Any] = Body(...)):
+            """Invoke a specific MCP tool."""
+            try:
+                result = await self.mcp_server.call_tool(tool_name, arguments=arguments)
+                return result
+            except Exception as e:
+                return {"error": f"Error invoking tool {tool_name}: {str(e)}"}
+
+    async def add_tool(self, tool: Callable[..., Any]) -> None:
+        """Add a tool to the MCP server."""
+        # Add tool to MCP server
+        self.mcp_server.add_tool(tool)
+        
+        # Get tool metadata
+        tools = await self.mcp_server.list_tools()
+        tool_metadata = tools[-1]
+        
+        # Convert FastMCP schema to our schema format
+        input_schema = tool_metadata.inputSchema
+        if isinstance(input_schema, dict):
+            if "$ref" in input_schema:
+                ref = input_schema["$ref"].split("/")[-1]
+                input_schema = tool_metadata.inputSchema.get("$defs", {}).get(ref, {})
+            
+            # Handle Pydantic model input
+            if "properties" in input_schema and "input" in input_schema["properties"]:
+                input_schema = input_schema["properties"]["input"]
+                if "$ref" in input_schema:
+                    ref = input_schema["$ref"].split("/")[-1]
+                    input_schema = tool_metadata.inputSchema.get("$defs", {}).get(ref, {})
+        
+        # Create and store Tool instance
+        self._tools[tool_metadata.name] = Tool(
+            name=tool_metadata.name,
+            description=tool_metadata.description,
+            input_schema=input_schema,
+            strict=True,
+            function=tool
+        ) 

mbxai/openrouter/__init__.py

@@ -0,0 +1,14 @@
+"""
+OpenRouter client module for MBX AI.
+"""
+
+from .client import OpenRouterClient
+from .config import OpenRouterConfig
+from .models import OpenRouterModel, OpenRouterModelRegistry
+
+__all__ = [
+    "OpenRouterClient",
+    "OpenRouterConfig",
+    "OpenRouterModel",
+    "OpenRouterModelRegistry",
+] 

mbxai/openrouter/client.py

@@ -0,0 +1,269 @@
+"""
+OpenRouter client implementation.
+"""
+
+from typing import Any, Optional, Union
+from openai import OpenAI, OpenAIError
+from pydantic import BaseModel, TypeAdapter
+from .models import OpenRouterModel, OpenRouterModelRegistry
+from .config import OpenRouterConfig
+
+
+class OpenRouterError(Exception):
+    """Base exception for OpenRouter client errors."""
+    pass
+
+
+class OpenRouterConnectionError(OpenRouterError):
+    """Raised when there is a connection error."""
+    pass
+
+
+class OpenRouterAPIError(OpenRouterError):
+    """Raised when the API returns an error."""
+    pass
+
+
+class OpenRouterClient:
+    """Client for interacting with the OpenRouter API."""
+
+    def __init__(
+        self,
+        token: str,
+        model: Union[str, OpenRouterModel] = OpenRouterModel.GPT4_TURBO,
+        base_url: Optional[str] = None,
+        default_headers: Optional[dict[str, str]] = None,
+    ) -> None:
+        """Initialize the OpenRouter client.
+
+        Args:
+            token: The OpenRouter API token
+            model: The model to use (default: GPT4_TURBO)
+            base_url: Optional custom base URL for the API
+            default_headers: Optional default headers for API requests
+
+        Raises:
+            OpenRouterError: If initialization fails
+        """
+        try:
+            self.config = OpenRouterConfig(
+                token=token,
+                model=model,
+                base_url=base_url or "https://openrouter.ai/api/v1",
+                default_headers=default_headers or {
+                    "HTTP-Referer": "https://github.com/mibexx/mbxai",
+                    "X-Title": "MBX AI",
+                }
+            )
+            
+            self._client = OpenAI(
+                api_key=token,
+                base_url=self.config.base_url,
+                default_headers=self.config.default_headers,
+            )
+        except Exception as e:
+            raise OpenRouterError(f"Failed to initialize client: {str(e)}")
+
+    def _handle_api_error(self, operation: str, error: Exception) -> None:
+        """Handle API errors.
+
+        Args:
+            operation: The operation being performed
+            error: The error that occurred
+
+        Raises:
+            OpenRouterConnectionError: For connection issues
+            OpenRouterAPIError: For API errors
+            OpenRouterError: For other errors
+        """
+        if isinstance(error, OpenAIError):
+            raise OpenRouterAPIError(f"API error during {operation}: {str(error)}")
+        elif "Connection" in str(error):
+            raise OpenRouterConnectionError(f"Connection error during {operation}: {str(error)}")
+        else:
+            raise OpenRouterError(f"Error during {operation}: {str(error)}")
+
+    @property
+    def model(self) -> str:
+        """Get the current model."""
+        return str(self.config.model)
+
+    @model.setter
+    def model(self, value: Union[str, OpenRouterModel]) -> None:
+        """Set a new model.
+
+        Args:
+            value: The new model to use
+        """
+        self.config.model = value
+
+    def set_model(self, value: Union[str, OpenRouterModel]) -> None:
+        """Set a new model.
+
+        Args:
+            value: The new model to use
+        """
+        self.model = value
+
+    def chat_completion(
+        self,
+        messages: list[dict[str, Any]],
+        *,
+        model: Optional[Union[str, OpenRouterModel]] = None,
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> Any:
+        """Create a chat completion.
+
+        Args:
+            messages: list of messages
+            model: Optional model override
+            stream: Whether to stream the response
+            **kwargs: Additional parameters
+
+        Returns:
+            Completion response
+
+        Raises:
+            OpenRouterConnectionError: For connection issues
+            OpenRouterAPIError: For API errors
+            OpenRouterError: For other errors
+        """
+        try:
+            # Remove any incompatible parameters
+            kwargs.pop("parse", None)  # Remove parse parameter if present
+            
+            return self._client.chat.completions.create(
+                model=str(model or self.model),
+                messages=messages,
+                stream=stream,
+                **kwargs,
+            )
+        except Exception as e:
+            self._handle_api_error("chat completion", e)
+
+    def chat_completion_parse(
+        self,
+        messages: list[dict[str, Any]],
+        response_format: type[BaseModel],
+        *,
+        model: Optional[Union[str, OpenRouterModel]] = None,
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> Any:
+        """Create a chat completion and parse the response.
+
+        Args:
+            messages: list of messages
+            response_format: Pydantic model to parse the response into
+            model: Optional model override
+            stream: Whether to stream the response
+            **kwargs: Additional parameters
+
+        Returns:
+            Parsed completion response
+
+        Raises:
+            OpenRouterConnectionError: For connection issues
+            OpenRouterAPIError: For API errors
+            OpenRouterError: For other errors
+            ValueError: If response parsing fails
+        """
+        try:
+            # Add system message to enforce JSON output if not present
+            if not any(msg.get("role") == "system" for msg in messages):
+                messages.insert(0, {
+                    "role": "system",
+                    "content": "You are a helpful assistant that responds in valid JSON format."
+                })
+            
+            # Add format instructions to user message
+            last_user_msg = next((msg for msg in reversed(messages) if msg.get("role") == "user"), None)
+            if last_user_msg:
+                format_desc = f"Respond with valid JSON matching this Pydantic model: {response_format.__name__}"
+                last_user_msg["content"] = f"{format_desc}\n\n{last_user_msg['content']}"
+            
+            response = self.chat_completion(
+                messages,
+                model=model,
+                stream=stream,
+                response_format={"type": "json_object"},  # Force JSON response
+                **kwargs
+            )
+            
+            if stream:
+                return response
+
+            # Parse the response content into the specified format
+            content = response.choices[0].message.content
+            adapter = TypeAdapter(response_format)
+            try:
+                parsed = adapter.validate_json(content)
+                response.choices[0].message.parsed = parsed
+                return response
+            except Exception as e:
+                raise ValueError(f"Failed to parse response as {response_format.__name__}: {str(e)}")
+        except ValueError as e:
+            raise e
+        except Exception as e:
+            self._handle_api_error("chat completion parse", e)
+
+    def embeddings(
+        self,
+        input: Union[str, list[str]],
+        *,
+        model: Optional[Union[str, OpenRouterModel]] = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Create embeddings.
+
+        Args:
+            input: Text to embed
+            model: Optional model override
+            **kwargs: Additional parameters
+
+        Returns:
+            Embeddings response
+
+        Raises:
+            OpenRouterConnectionError: For connection issues
+            OpenRouterAPIError: For API errors
+            OpenRouterError: For other errors
+        """
+        try:
+            # Remove any incompatible parameters
+            kwargs.pop("parse", None)  # Remove parse parameter if present
+            
+            # Use text-embedding-ada-002 for embeddings
+            embeddings_model = "openai/text-embedding-ada-002"
+            
+            return self._client.embeddings.create(
+                model=str(model or embeddings_model),
+                input=input if isinstance(input, list) else [input],
+                encoding_format="float",  # Use float format instead of base64
+                **kwargs,
+            )
+        except Exception as e:
+            self._handle_api_error("embeddings", e)
+
+    @classmethod
+    def register_model(cls, name: str, value: str) -> None:
+        """Register a new model.
+
+        Args:
+            name: The name of the model (e.g., "CUSTOM_MODEL")
+            value: The model identifier (e.g., "provider/model-name")
+
+        Raises:
+            ValueError: If the model name is already registered.
+        """
+        OpenRouterModelRegistry.register_model(name, value)
+
+    @classmethod
+    def list_models(cls) -> dict[str, str]:
+        """List all available models.
+
+        Returns:
+            A dictionary mapping model names to their identifiers.
+        """
+        return OpenRouterModelRegistry.list_models() 

mbxai/openrouter/config.py

@@ -0,0 +1,71 @@
+from pydantic import BaseModel, Field, field_validator
+from typing import Union
+from .models import OpenRouterModel, OpenRouterModelRegistry
+
+class OpenRouterConfig(BaseModel):
+    """Configuration for OpenRouter client."""
+    
+    token: str = Field(..., description="OpenRouter API token")
+    model: Union[str, OpenRouterModel] = Field(
+        default=OpenRouterModel.GPT4_TURBO,
+        description="Model to use for completions"
+    )
+    base_url: str = Field(
+        default="https://openrouter.ai/api/v1",
+        description="Base URL for the OpenRouter API"
+    )
+    default_headers: dict[str, str] = Field(
+        default_factory=lambda: {
+            "HTTP-Referer": "https://github.com/mibexx/mbxai",
+            "X-Title": "MBX AI",
+        },
+        description="Default headers to include in all requests"
+    )
+
+    @field_validator("token")
+    def validate_token(cls, v: str) -> str:
+        """Validate that the token is not empty."""
+        if not v or not v.strip():
+            raise ValueError("Token cannot be empty")
+        return v.strip()
+
+    @field_validator("base_url")
+    def validate_base_url(cls, v: str) -> str:
+        """Validate that the base URL is a valid URL."""
+        if not v:
+            raise ValueError("Base URL cannot be empty")
+        if not v.startswith(("http://", "https://")):
+            raise ValueError("Base URL must start with http:// or https://")
+        return v.rstrip("/") + "/"  # Always include trailing slash
+
+    @field_validator("model")
+    def validate_model(cls, v: Union[str, OpenRouterModel]) -> str:
+        """Validate and convert model to string."""
+        if isinstance(v, OpenRouterModel):
+            return v.value
+        if not v:
+            raise ValueError("Model cannot be empty")
+        
+        # Try to get model from registry first
+        try:
+            return OpenRouterModelRegistry.get_model(v)
+        except ValueError:
+            # If not in registry, check if it's a valid provider/model format
+            if "/" not in v:
+                raise ValueError("Custom model must be in format 'provider/model-name'")
+            return str(v)
+
+    @field_validator("default_headers")
+    def validate_headers(cls, v: dict[str, str]) -> dict[str, str]:
+        """Validate that required headers are present and valid."""
+        required_headers = {"HTTP-Referer", "X-Title"}
+        missing_headers = required_headers - set(v.keys())
+        if missing_headers:
+            raise ValueError(f"Missing required headers: {', '.join(missing_headers)}")
+        
+        # Ensure header values are not empty
+        empty_headers = [k for k, val in v.items() if not val or not val.strip()]
+        if empty_headers:
+            raise ValueError(f"Empty values for headers: {', '.join(empty_headers)}")
+        
+        return {k: val.strip() for k, val in v.items()} 

mbxai/openrouter/models.py

@@ -0,0 +1,87 @@
+"""OpenRouter models and model registry."""
+
+from enum import Enum
+from typing import ClassVar
+
+class OpenRouterModel(str, Enum):
+    """Built-in OpenRouter models."""
+
+    GPT4_TURBO = "openai/gpt-4-turbo-preview"
+    GPT4 = "openai/gpt-4"
+    GPT41 = "openai/gpt-4.1"
+    GPT35_TURBO = "openai/gpt-3.5-turbo"
+    CLAUDE_3_OPUS = "anthropic/claude-3-opus"
+    CLAUDE_3_SONNET = "anthropic/claude-3-sonnet"
+    CLAUDE_3_HAIKU = "anthropic/claude-3-haiku"
+    GEMINI_PRO = "google/gemini-pro"
+    MIXTRAL_8X7B = "mistral/mixtral-8x7b"
+    MISTRAL_MEDIUM = "mistral/mistral-medium"
+    MISTRAL_SMALL = "mistral/mistral-small"
+    MISTRAL_TINY = "mistral/mistral-tiny"
+
+class OpenRouterModelRegistry:
+    """Registry for OpenRouter models."""
+
+    _custom_models: ClassVar[dict[str, str]] = {}
+    _initialized: ClassVar[bool] = False
+
+    @classmethod
+    def _initialize(cls) -> None:
+        """Initialize the registry if not already initialized."""
+        if not cls._initialized:
+            cls._custom_models = {}
+            cls._initialized = True
+
+    @classmethod
+    def register_model(cls, name: str, value: str) -> None:
+        """Register a new model.
+
+        Args:
+            name: The name of the model (e.g., "CUSTOM_MODEL")
+            value: The model identifier (e.g., "provider/model-name")
+
+        Raises:
+            ValueError: If the model name is already registered.
+        """
+        cls._initialize()
+        if name in cls._custom_models:
+            # If the value is the same, just return
+            if cls._custom_models[name] == value:
+                return
+            raise ValueError(f"Model {name} is already registered")
+        cls._custom_models[name] = value
+
+    @classmethod
+    def get_model(cls, name: str) -> str:
+        """Get a model by name.
+
+        Args:
+            name: The name of the model
+
+        Returns:
+            The model identifier
+
+        Raises:
+            ValueError: If the model is not found.
+        """
+        cls._initialize()
+        try:
+            return OpenRouterModel[name].value
+        except KeyError:
+            try:
+                return cls._custom_models[name]
+            except KeyError:
+                raise ValueError(f"Model {name} not found")
+
+    @classmethod
+    def list_models(cls) -> dict[str, str]:
+        """List all available models.
+
+        Returns:
+            A dictionary mapping model names to their identifiers.
+        """
+        cls._initialize()
+        return {
+            **{model.name: model.value for model in OpenRouterModel},
+            **cls._custom_models,
+        } 

mbxai/tools/__init__.py

@@ -0,0 +1,12 @@
+"""
+Tools module for MBX AI.
+"""
+
+from .client import ToolClient
+from .types import Tool, ToolCall
+
+__all__ = [
+    "ToolClient",
+    "Tool",
+    "ToolCall",
+] 

mbxai/tools/client.py

@@ -0,0 +1,172 @@
+"""
+ToolClient implementation for MBX AI.
+"""
+
+from typing import Any, Callable, TypeVar, cast
+from pydantic import BaseModel
+from ..openrouter import OpenRouterClient
+from .types import Tool, ToolCall
+
+T = TypeVar("T", bound=BaseModel)
+
+class ToolClient:
+    """Client for handling tool calls with OpenRouter."""
+
+    def __init__(self, openrouter_client: OpenRouterClient) -> None:
+        """Initialize the ToolClient.
+
+        Args:
+            openrouter_client: The OpenRouter client to use
+        """
+        self._client = openrouter_client
+        self._tools: dict[str, Tool] = {}
+
+    def register_tool(
+        self,
+        name: str,
+        description: str,
+        function: Callable[..., Any],
+        schema: dict[str, Any],
+    ) -> None:
+        """Register a new tool.
+
+        Args:
+            name: The name of the tool
+            description: A description of what the tool does
+            function: The function to call when the tool is used
+            schema: The JSON schema for the tool's parameters
+        """
+        tool = Tool(
+            name=name,
+            description=description,
+            function=function,
+            schema=schema,
+        )
+        self._tools[name] = tool
+
+    def chat(
+        self,
+        messages: list[dict[str, Any]],
+        *,
+        model: str | None = None,
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> Any:
+        """Chat with the model, handling tool calls.
+
+        Args:
+            messages: The conversation messages
+            model: Optional model override
+            stream: Whether to stream the response
+            **kwargs: Additional parameters for the chat completion
+
+        Returns:
+            The final response from the model
+        """
+        tools = [tool.to_openai_function() for tool in self._tools.values()]
+        
+        while True:
+            # Add tools to the request if we have any
+            if tools:
+                kwargs["tools"] = tools
+                kwargs["tool_choice"] = "auto"
+
+            # Get the model's response
+            response = self._client.chat_completion(
+                messages=messages,
+                model=model,
+                stream=stream,
+                **kwargs,
+            )
+
+            if stream:
+                return response
+
+            message = response.choices[0].message
+            messages.append({"role": "assistant", "content": message.content})
+
+            # If there are no tool calls, we're done
+            if not message.tool_calls:
+                return response
+
+            # Handle each tool call
+            for tool_call in message.tool_calls:
+                tool = self._tools.get(tool_call.function.name)
+                if not tool:
+                    raise ValueError(f"Unknown tool: {tool_call.function.name}")
+
+                # Call the tool
+                result = tool.function(**tool_call.function.arguments)
+
+                # Add the tool response to the messages
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": tool_call.id,
+                    "name": tool_call.function.name,
+                    "content": str(result),
+                })
+
+    def parse(
+        self,
+        messages: list[dict[str, Any]],
+        response_format: type[T],
+        *,
+        model: str | None = None,
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> Any:
+        """Chat with the model and parse the response into a Pydantic model.
+
+        Args:
+            messages: The conversation messages
+            response_format: The Pydantic model to parse the response into
+            model: Optional model override
+            stream: Whether to stream the response
+            **kwargs: Additional parameters for the chat completion
+
+        Returns:
+            The parsed response from the model
+        """
+        tools = [tool.to_openai_function() for tool in self._tools.values()]
+        
+        while True:
+            # Add tools to the request if we have any
+            if tools:
+                kwargs["tools"] = tools
+                kwargs["tool_choice"] = "auto"
+
+            # Get the model's response
+            response = self._client.chat_completion_parse(
+                messages=messages,
+                response_format=response_format,
+                model=model,
+                stream=stream,
+                **kwargs,
+            )
+
+            if stream:
+                return response
+
+            message = response.choices[0].message
+            messages.append({"role": "assistant", "content": message.content})
+
+            # If there are no tool calls, we're done
+            if not message.tool_calls:
+                return response
+
+            # Handle each tool call
+            for tool_call in message.tool_calls:
+                tool = self._tools.get(tool_call.function.name)
+                if not tool:
+                    raise ValueError(f"Unknown tool: {tool_call.function.name}")
+
+                # Call the tool
+                result = tool.function(**tool_call.function.arguments)
+
+                # Add the tool response to the messages
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": tool_call.id,
+                    "name": tool_call.function.name,
+                    "content": str(result),
+                }) 

mbxai/tools/example.py

@@ -0,0 +1,75 @@
+"""
+Example usage of the ToolClient.
+"""
+
+from pydantic import BaseModel
+from ..openrouter import OpenRouterClient, OpenRouterModel
+from .client import ToolClient
+
+# Define a Pydantic model for structured output
+class WeatherInfo(BaseModel):
+    """Weather information for a location."""
+    location: str
+    temperature: float
+    conditions: str
+    humidity: float
+
+# Example tool function
+def get_weather(location: str) -> str:
+    """Get the current weather for a location.
+    
+    Args:
+        location: The location to get weather for
+        
+    Returns:
+        A string describing the current weather
+    """
+    # In a real implementation, this would call a weather API
+    return f"The weather in {location} is sunny with a temperature of 25°C and 60% humidity."
+
+def main() -> None:
+    # Initialize the OpenRouter client
+    client = OpenRouterClient(token="your-api-key")
+    
+    # Initialize the ToolClient
+    tool_client = ToolClient(client)
+    
+    # Register the weather tool
+    tool_client.register_tool(
+        name="get_weather",
+        description="Get the current weather for a location",
+        function=get_weather,
+        schema={
+            "type": "object",
+            "properties": {
+                "location": {
+                    "type": "string",
+                    "description": "The location to get weather for"
+                }
+            },
+            "required": ["location"]
+        }
+    )
+    
+    # Example 1: Simple chat with tool usage
+    messages = [
+        {"role": "user", "content": "What's the weather like in New York?"}
+    ]
+    
+    response = tool_client.chat(messages)
+    print(response.choices[0].message.content)
+    
+    # Example 2: Structured output with tool usage
+    messages = [
+        {"role": "user", "content": "Get the weather in London and format it as structured data"}
+    ]
+    
+    response = tool_client.parse(messages, WeatherInfo)
+    weather_info = response.choices[0].message.parsed
+    print(f"Location: {weather_info.location}")
+    print(f"Temperature: {weather_info.temperature}°C")
+    print(f"Conditions: {weather_info.conditions}")
+    print(f"Humidity: {weather_info.humidity}%")
+
+if __name__ == "__main__":
+    main() 

mbxai/tools/types.py

@@ -0,0 +1,33 @@
+"""
+Type definitions for the tools package.
+"""
+
+from typing import Any, Callable, TypedDict, NotRequired
+from pydantic import BaseModel
+
+class ToolFunction(TypedDict):
+    """OpenAI function definition for a tool."""
+    name: str
+    description: str
+    parameters: dict[str, Any]
+
+class ToolCall(BaseModel):
+    """A tool call from the model."""
+    id: str
+    name: str
+    arguments: dict[str, Any]
+
+class Tool(BaseModel):
+    """A tool that can be used by the model."""
+    name: str
+    description: str
+    function: Callable[..., Any]
+    schema: dict[str, Any]
+
+    def to_openai_function(self) -> ToolFunction:
+        """Convert the tool to an OpenAI function definition."""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "parameters": self.schema,
+        } 

mbxai-0.1.0.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: mbxai
+Version: 0.1.0
+Summary: MBX AI SDK
+Project-URL: Homepage, https://www.mibexx.de
+Project-URL: Documentation, https://www.mibexx.de
+Project-URL: Repository, https://github.com/yourusername/mbxai.git
+Author: MBX AI
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Requires-Dist: fastapi>=0.115.12
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp>=1.7.1
+Requires-Dist: openai>=1.77.0
+Requires-Dist: pydantic-settings>=2.9.1
+Requires-Dist: pydantic>=2.9.1
+Requires-Dist: python-multipart>=0.0.20
+Requires-Dist: sse-starlette>=2.3.4
+Requires-Dist: starlette>=0.46.2
+Requires-Dist: uvicorn>=0.34.2
+Provides-Extra: dev
+Requires-Dist: black>=24.3.0; extra == 'dev'
+Requires-Dist: isort>=5.13.2; extra == 'dev'
+Requires-Dist: mypy>=1.8.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.26.0; extra == 'dev'
+Requires-Dist: pytest-cov>=6.1.1; extra == 'dev'
+Requires-Dist: pytest>=8.3.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# MBX AI
+
+A Python library for building AI applications with LLMs.
+
+## Features
+
+- **OpenRouter Integration**: Connect to various LLM providers through OpenRouter
+- **Tool Integration**: Easily integrate tools with LLMs using the Model Context Protocol (MCP)
+- **Structured Output**: Get structured, typed responses from LLMs
+- **Chat Interface**: Simple chat interface for interacting with LLMs
+- **FastAPI Server**: Built-in FastAPI server for tool integration
+
+## Installation
+
+```bash
+pip install mbxai
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from mbxai import OpenRouterClient
+
+# Initialize the client
+client = OpenRouterClient(api_key="your-api-key")
+
+# Chat with an LLM
+response = await client.chat([
+    {"role": "user", "content": "Hello, how are you?"}
+])
+print(response.choices[0].message.content)
+```
+
+### Using Tools
+
+```python
+from mbxai import OpenRouterClient, ToolClient
+from pydantic import BaseModel
+
+# Define your tool's input and output models
+class CalculatorInput(BaseModel):
+    a: float
+    b: float
+
+class CalculatorOutput(BaseModel):
+    result: float
+
+# Create a calculator tool
+async def calculator(input: CalculatorInput) -> CalculatorOutput:
+    return CalculatorOutput(result=input.a + input.b)
+
+# Initialize the client with tools
+client = ToolClient(OpenRouterClient(api_key="your-api-key"))
+client.add_tool(calculator)
+
+# Use the tool in a chat
+response = await client.chat([
+    {"role": "user", "content": "What is 2 + 3?"}
+])
+print(response.choices[0].message.content)
+```
+
+### Using MCP (Model Context Protocol)
+
+```python
+from mbxai import OpenRouterClient, MCPClient
+from mbxai.mcp import MCPServer
+from mcp.server.fastmcp import FastMCP
+from pydantic import BaseModel
+
+# Define your tool's input and output models
+class CalculatorInput(BaseModel):
+    a: float
+    b: float
+
+class CalculatorOutput(BaseModel):
+    result: float
+
+# Create a FastMCP instance
+mcp = FastMCP("calculator-service")
+
+# Create a calculator tool
+@mcp.tool()
+async def calculator(argument: CalculatorInput) -> CalculatorOutput:
+    return CalculatorOutput(result=argument.a + argument.b)
+
+# Start the MCP server
+server = MCPServer("calculator-service")
+await server.add_tool(calculator)
+await server.start()
+
+# Initialize the MCP client
+client = MCPClient(OpenRouterClient(api_key="your-api-key"))
+await client.register_mcp_server("calculator-service", "http://localhost:8000")
+
+# Use the tool in a chat
+response = await client.chat([
+    {"role": "user", "content": "What is 2 + 3?"}
+])
+print(response.choices[0].message.content)
+```
+
+## Development
+
+### Setup
+
+1. Clone the repository:
+```bash
+git clone https://github.com/yourusername/mbxai.git
+cd mbxai
+```
+
+2. Create a virtual environment:
+```bash
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+```
+
+3. Install dependencies:
+```bash
+pip install -e ".[dev]"
+```
+
+### Running Tests
+
+```bash
+pytest tests/
+```
+
+## License
+
+MIT License

mbxai-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+mbxai/__init__.py,sha256=K4smKVZXrhcJYppSx5ZVow5BySoCQFVW6fgtPb9MUec,47
+mbxai/core.py,sha256=WMvmU9TTa7M_m-qWsUew4xH8Ul6xseCZ2iBCXJTW-Bs,196
+mbxai/mcp/__init__.py,sha256=_ek9iYdYqW5saKetj4qDci11jxesQDiHPJRpHMKkxgU,175
+mbxai/mcp/client.py,sha256=rVYYsWSSUWmF9lWHFeFiPOnqD5yU-N1A9ApXekfhwVg,4411
+mbxai/mcp/example.py,sha256=oaol7AvvZnX86JWNz64KvPjab5gg1VjVN3G8eFSzuaE,2350
+mbxai/mcp/server.py,sha256=pV6GskuQvutmXw0bsazlZdGktAcw9u0tF_o-AYFIGQg,3495
+mbxai/openrouter/__init__.py,sha256=Ito9Qp_B6q-RLGAQcYyTJVWwR2YAZvNqE-HIYXxhtD8,298
+mbxai/openrouter/client.py,sha256=NPccB7Slou5tSc8DvXvItLdoDMgU0pcxW1lKcRKQXp0,8865
+mbxai/openrouter/config.py,sha256=MTX_YHsFrM7JYqovJSkEF6JzVyIdajeI5Dja2CALH58,2874
+mbxai/openrouter/models.py,sha256=b3IjjtZAjeGOf2rLsdnCD1HacjTnS8jmv_ZXorc-KJQ,2604
+mbxai/tools/__init__.py,sha256=QUFaXhDm-UKcuAtT1rbKzhBkvyRBVokcQIOf9cxIuwc,160
+mbxai/tools/client.py,sha256=PDkDTvpwAs8-F8CcF6wjjq2Z-VhYpjA9RXTK64Rwa3Y,5418
+mbxai/tools/example.py,sha256=1HgKK39zzUuwFbnp3f0ThyWVfA_8P28PZcTwaUw5K78,2232
+mbxai/tools/types.py,sha256=ZHnmiDXpH6wZhiZ-Tj9PiPMJaW1aiDAq5It2gpiwNp0,831
+mbxai-0.1.0.dist-info/METADATA,sha256=_pSF7GYV38BFNkaHUR0FUj4NAzH2fH49R32n0HXqYWI,4107
+mbxai-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mbxai-0.1.0.dist-info/licenses/LICENSE,sha256=hEyhc4FxwYo3NQ40yNgZ7STqwVk-1_XcTXOnAPbGJAw,1069
+mbxai-0.1.0.dist-info/RECORD,,

mbxai-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mbxai-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mike Bertram
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.