mbxai 0.1.0__tar.gz

mbxai-0.1.0/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. 

mbxai-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,134 @@
+# 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/pyproject.toml

@@ -0,0 +1,86 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mbxai"
+version = "0.1.0"
+authors = [
+    { name = "MBX AI" }
+]
+description = "MBX AI SDK"
+readme = "README.md"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+keywords = []
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "httpx>=0.27.0",
+    "pydantic>=2.9.1",
+    "fastapi>=0.115.12",
+    "mcp>=1.7.1",
+    "openai>=1.77.0",
+    "python-multipart>=0.0.20",
+    "sse-starlette>=2.3.4",
+    "starlette>=0.46.2",
+    "uvicorn>=0.34.2",
+    "pydantic-settings>=2.9.1"
+]
+
+[project.urls]
+Homepage = "https://www.mibexx.de"
+Documentation = "https://www.mibexx.de"
+Repository = "https://github.com/yourusername/mbxai.git"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.3.5",
+    "pytest-asyncio>=0.26.0",
+    "pytest-cov>=6.1.1",
+    "black>=24.3.0",
+    "isort>=5.13.2",
+    "mypy>=1.8.0"
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mbxai"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+addopts = "-v"
+
+[tool.black]
+line-length = 100
+target-version = ["py312"]
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+line_length = 100
+
+[tool.mypy]
+python_version = "3.12"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+disallow_untyped_decorators = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+warn_unreachable = true
+strict_equality = true 
+
+[dependency-groups]
+dev = [
+    "build>=1.2.2.post1",
+    "twine>=6.1.0",
+]

mbxai-0.1.0/setup.py

@@ -0,0 +1,47 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="mbxai",
+    version="0.1.0",
+    author="MBX AI",
+    description="MBX AI SDK",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    python_requires=">=3.12",
+    license="MIT",
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3.12",
+        "Operating System :: OS Independent",
+    ],
+    package_dir={"": "src"},
+    packages=find_packages(where="src"),
+    install_requires=[
+        "httpx>=0.27.0",
+        "pydantic>=2.9.1",
+        "fastapi>=0.115.12",
+        "mcp>=1.7.1",
+        "openai>=1.77.0",
+        "python-multipart>=0.0.20",
+        "sse-starlette>=2.3.4",
+        "starlette>=0.46.2",
+        "uvicorn>=0.34.2",
+        "pydantic-settings>=2.9.1"
+    ],
+    extras_require={
+        "dev": [
+            "pytest>=8.3.5",
+            "pytest-asyncio>=0.26.0",
+            "pytest-cov>=6.1.1",
+            "black>=24.3.0",
+            "isort>=5.13.2",
+            "mypy>=1.8.0"
+        ]
+    },
+    project_urls={
+        "Homepage": "https://www.mibexx.de",
+        "Documentation": "https://www.mibexx.de",
+        "Repository": "https://gitlab.com/mbxai/mbxai-sdk.git"
+    }
+) 

mbxai-0.1.0/src/mbxai/__init__.py

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

mbxai-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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())