mbxai 0.7.3__tar.gz → 0.8.1__tar.gz

{mbxai-0.7.3 → mbxai-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mbxai
-Version: 0.7.3
+Version: 0.8.1
 Summary: MBX AI SDK
 Project-URL: Homepage, https://www.mibexx.de
 Project-URL: Documentation, https://www.mibexx.de

{mbxai-0.7.3 → mbxai-0.8.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mbxai"
-version = "0.7.3"
+version = "0.8.1"
 authors = [
     { name = "MBX AI" }
 ]

{mbxai-0.7.3 → mbxai-0.8.1}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="mbxai",
-    version="0.7.3",
+    version="0.8.1",
     author="MBX AI",
     description="MBX AI SDK",
     long_description=open("README.md").read(),

{mbxai-0.7.3 → mbxai-0.8.1}/src/mbxai/__init__.py

@@ -2,4 +2,4 @@
 MBX AI package.
 """
 
-__version__ = "0.7.3" 
+__version__ = "0.8.1" 

mbxai-0.8.1/src/mbxai/examples/openrouter_example.py

@@ -0,0 +1,45 @@
+"""
+Example script demonstrating basic usage of the OpenRouterClient.
+"""
+
+import os
+import logging
+from mbxai.openrouter.client import OpenRouterClient, OpenRouterModel
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+def main():
+    # Get API token from environment variable
+    token = os.getenv("OPENROUTER_API_KEY")
+    if not token:
+        logger.error("OPENROUTER_API_KEY environment variable not set")
+        raise ValueError("Please set the OPENROUTER_API_KEY environment variable")
+
+    logger.info("Initializing OpenRouterClient with GPT-4 Turbo")
+    # Initialize the client
+    client = OpenRouterClient(
+        token=token,
+        model=OpenRouterModel.GPT4_TURBO  # Using GPT-4 Turbo as default
+    )
+
+    # Example messages
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "What is the capital of France?"}
+    ]
+
+    logger.info("Sending request to OpenRouter API")
+    # Send the request
+    response = client.create(messages=messages)
+
+    # Log the response
+    logger.info("Received response from OpenRouter API")
+    logger.info(f"Response: {response}")
+
+if __name__ == "__main__":
+    main() 

mbxai-0.8.1/src/mbxai/examples/parse_example.py

@@ -0,0 +1,99 @@
+"""
+Example script demonstrating how to use the parse function with OpenRouterClient.
+"""
+
+import os
+import logging
+from typing import Any
+from pydantic import BaseModel, Field
+from mbxai.openrouter.client import OpenRouterClient, OpenRouterModel
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Define a Pydantic model for structured weather data
+class WeatherData(BaseModel):
+    """Weather data for a location."""
+    location: str = Field(..., description="The city name")
+    temperature: float = Field(..., description="Temperature in Celsius")
+    condition: str = Field(..., description="Weather condition (e.g., sunny, cloudy)")
+    humidity: float = Field(..., description="Humidity percentage")
+    wind_speed: float = Field(..., description="Wind speed in km/h")
+    feels_like: float = Field(..., description="Feels like temperature in Celsius")
+    precipitation_chance: float = Field(..., description="Chance of precipitation as a percentage")
+
+async def main():
+    # Get API token from environment variable
+    token = os.getenv("OPENROUTER_API_KEY")
+    if not token:
+        raise ValueError("Please set the OPENROUTER_API_KEY environment variable")
+
+    # Initialize the OpenRouter client
+    logger.info("Initializing OpenRouter client")
+    client = OpenRouterClient(
+        token=token,
+        model=OpenRouterModel.GPT41
+    )
+    
+    # Example 1: Parse weather data for a single location
+    logger.info("Parsing weather data for New York")
+    messages = [
+        {
+            "role": "user", 
+            "content": "What's the current weather in New York? Please provide temperature, condition, humidity, wind speed, feels like temperature, and precipitation chance."
+        }
+    ]
+    
+    response = client.parse(
+        messages=messages,
+        response_format=WeatherData,
+        timeout=30.0,
+    )
+    
+    weather_data = response.choices[0].message.parsed
+    print("\nWeather data for New York:")
+    print(f"Location: {weather_data.location}")
+    print(f"Temperature: {weather_data.temperature}°C")
+    print(f"Condition: {weather_data.condition}")
+    print(f"Humidity: {weather_data.humidity}%")
+    print(f"Wind Speed: {weather_data.wind_speed} km/h")
+    print(f"Feels Like: {weather_data.feels_like}°C")
+    print(f"Precipitation Chance: {weather_data.precipitation_chance}%")
+    
+    # Example 2: Parse weather data for multiple locations
+    logger.info("\nParsing weather data for multiple locations")
+    messages = [
+        {
+            "role": "user", 
+            "content": "Compare the weather in London and Tokyo. For each city, provide temperature, condition, humidity, wind speed, feels like temperature, and precipitation chance."
+        }
+    ]
+    
+    class MultiLocationWeather(BaseModel):
+        """Weather data for multiple locations."""
+        locations: list[WeatherData] = Field(..., description="List of weather data for different locations")
+    
+    response = client.parse(
+        messages=messages,
+        response_format=MultiLocationWeather,
+        timeout=30.0,
+    )
+    
+    multi_weather = response.choices[0].message.parsed
+    print("\nWeather comparison:")
+    for location_data in multi_weather.locations:
+        print(f"\n{location_data.location}:")
+        print(f"Temperature: {location_data.temperature}°C")
+        print(f"Condition: {location_data.condition}")
+        print(f"Humidity: {location_data.humidity}%")
+        print(f"Wind Speed: {location_data.wind_speed} km/h")
+        print(f"Feels Like: {location_data.feels_like}°C")
+        print(f"Precipitation Chance: {location_data.precipitation_chance}%")
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main()) 

mbxai-0.8.1/src/mbxai/examples/parse_tool_example.py

@@ -0,0 +1,144 @@
+"""
+Example script demonstrating how to use both parse and tools with OpenRouterClient.
+"""
+
+import os
+import logging
+import random
+from typing import Any
+from pydantic import BaseModel, Field
+from mbxai.openrouter.client import OpenRouterClient, OpenRouterModel
+from mbxai.tools.client import ToolClient
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Define a Pydantic model for structured weather data
+class WeatherData(BaseModel):
+    """Weather data for a location."""
+    location: str = Field(..., description="The city name")
+    temperature: float = Field(..., description="Temperature in Celsius")
+    condition: str = Field(..., description="Weather condition (e.g., sunny, cloudy)")
+    humidity: float = Field(..., description="Humidity percentage")
+    wind_speed: float = Field(..., description="Wind speed in km/h")
+    feels_like: float = Field(..., description="Feels like temperature in Celsius")
+    precipitation_chance: float = Field(..., description="Chance of precipitation as a percentage")
+
+# Mock weather data for demonstration
+WEATHER_DATA = {
+    "new york": {"temperature": 22.5, "condition": "sunny", "humidity": 65, "wind_speed": 12, "feels_like": 23.0, "precipitation_chance": 10},
+    "london": {"temperature": 18.2, "condition": "cloudy", "humidity": 75, "wind_speed": 8, "feels_like": 17.5, "precipitation_chance": 40},
+    "tokyo": {"temperature": 25.7, "condition": "clear", "humidity": 60, "wind_speed": 5, "feels_like": 26.0, "precipitation_chance": 5},
+    "paris": {"temperature": 20.1, "condition": "partly cloudy", "humidity": 70, "wind_speed": 10, "feels_like": 19.5, "precipitation_chance": 20},
+}
+
+def get_weather(location: str) -> dict[str, Any]:
+    """Get weather information for a location.
+    
+    Args:
+        location: The city name to get weather for
+        
+    Returns:
+        Weather information including temperature, condition, humidity, and wind speed
+    """
+    logger.info(f"Getting weather for location: {location}")
+    
+    # Convert location to lowercase for case-insensitive matching
+    location = location.lower()
+    
+    # Get weather data or generate random data for unknown locations
+    if location in WEATHER_DATA:
+        weather = WEATHER_DATA[location]
+    else:
+        logger.warning(f"No weather data for {location}, generating random data")
+        weather = {
+            "temperature": round(random.uniform(15, 30), 1),
+            "condition": random.choice(["sunny", "cloudy", "clear", "partly cloudy"]),
+            "humidity": round(random.uniform(50, 90)),
+            "wind_speed": round(random.uniform(5, 20)),
+            "feels_like": round(random.uniform(15, 30), 1),
+            "precipitation_chance": round(random.uniform(0, 100))
+        }
+    
+    # Create WeatherData instance
+    weather_data = WeatherData(
+        location=location.title(),
+        temperature=weather["temperature"],
+        condition=weather["condition"],
+        humidity=weather["humidity"],
+        wind_speed=weather["wind_speed"],
+        feels_like=weather["feels_like"],
+        precipitation_chance=weather["precipitation_chance"]
+    )
+    
+    logger.info(f"Weather data retrieved: {weather_data}")
+    return weather_data.model_dump()
+
+async def main():
+    # Get API token from environment variable
+    token = os.getenv("OPENROUTER_API_KEY")
+    if not token:
+        raise ValueError("Please set the OPENROUTER_API_KEY environment variable")
+
+    # Initialize the OpenRouter client
+    logger.info("Initializing OpenRouter client")
+    openrouter_client = OpenRouterClient(
+        token=token,
+        model=OpenRouterModel.GPT41
+    )
+    
+    # Initialize the ToolClient
+    logger.info("Initializing ToolClient")
+    tool_client = ToolClient(openrouter_client)
+    
+    # Register the weather tool
+    logger.info("Registering 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 city name to get weather for"
+                }
+            },
+            "required": ["location"]
+        }
+    )
+    
+    # Example 1: Get weather for a single location using tools and parse
+    logger.info("Getting weather for New York using tools and parse")
+    messages = [
+        {
+            "role": "user", 
+            "content": "What's the current weather in New York? Use the get_weather tool and format the response according to the WeatherData model."
+        }
+    ]
+    
+    response = tool_client.parse(
+        messages=messages,
+        response_format=WeatherData,
+        timeout=30.0,
+    )
+    
+    weather_data = response.choices[0].message.parsed
+    print("\nWeather data for New York:")
+    print(f"Location: {weather_data.location}")
+    print(f"Temperature: {weather_data.temperature}°C")
+    print(f"Condition: {weather_data.condition}")
+    print(f"Humidity: {weather_data.humidity}%")
+    print(f"Wind Speed: {weather_data.wind_speed} km/h")
+    print(f"Feels Like: {weather_data.feels_like}°C")
+    print(f"Precipitation Chance: {weather_data.precipitation_chance}%")
+
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main()) 

mbxai-0.8.1/src/mbxai/examples/tool_client_example.py

@@ -0,0 +1,126 @@
+"""
+Example script demonstrating how to use the ToolClient with a custom Weather Tool.
+"""
+
+import os
+import logging
+import random
+from typing import Any
+from pydantic import BaseModel
+from mbxai.openrouter.client import OpenRouterClient, OpenRouterModel
+from mbxai.tools.client import ToolClient
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Define the weather data model
+class WeatherData(BaseModel):
+    """Weather data for a location."""
+    location: str
+    temperature: float
+    condition: str
+    humidity: float
+    wind_speed: float
+
+# Mock weather data for demonstration
+WEATHER_DATA = {
+    "new york": {"temperature": 22.5, "condition": "sunny", "humidity": 65, "wind_speed": 12},
+    "london": {"temperature": 18.2, "condition": "cloudy", "humidity": 75, "wind_speed": 8},
+    "tokyo": {"temperature": 25.7, "condition": "clear", "humidity": 60, "wind_speed": 5},
+    "paris": {"temperature": 20.1, "condition": "partly cloudy", "humidity": 70, "wind_speed": 10},
+}
+
+def get_weather(location: str) -> dict[str, Any]:
+    """Get weather information for a location.
+    
+    Args:
+        location: The city name to get weather for
+        
+    Returns:
+        Weather information including temperature, condition, humidity, and wind speed
+    """
+    logger.info(f"Getting weather for location: {location}")
+    
+    # Convert location to lowercase for case-insensitive matching
+    location = location.lower()
+    
+    # Get weather data or generate random data for unknown locations
+    if location in WEATHER_DATA:
+        weather = WEATHER_DATA[location]
+    else:
+        logger.warning(f"No weather data for {location}, generating random data")
+        weather = {
+            "temperature": round(random.uniform(15, 30), 1),
+            "condition": random.choice(["sunny", "cloudy", "clear", "partly cloudy"]),
+            "humidity": round(random.uniform(50, 90)),
+            "wind_speed": round(random.uniform(5, 20))
+        }
+    
+    # Create WeatherData instance
+    weather_data = WeatherData(
+        location=location.title(),
+        temperature=weather["temperature"],
+        condition=weather["condition"],
+        humidity=weather["humidity"],
+        wind_speed=weather["wind_speed"]
+    )
+    
+    logger.info(f"Weather data retrieved: {weather_data}")
+    return weather_data.model_dump()
+
+async def main():
+    # Get API token from environment variable
+    token = os.getenv("OPENROUTER_API_KEY")
+    if not token:
+        raise ValueError("Please set the OPENROUTER_API_KEY environment variable")
+
+    # Initialize the OpenRouter client
+    logger.info("Initializing OpenRouter client")
+    openrouter_client = OpenRouterClient(
+        token=token,
+        model=OpenRouterModel.GPT35_TURBO
+    )
+    
+    # Initialize the ToolClient
+    logger.info("Initializing ToolClient")
+    tool_client = ToolClient(openrouter_client)
+    
+    # Register the weather tool
+    logger.info("Registering 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 city name to get weather for"
+                }
+            },
+            "required": ["location"]
+        }
+    )
+    
+    # Example 1: Simple weather query
+    logger.info("Sending weather query for New York")
+    messages = [
+        {"role": "user", "content": "What's the weather like in New York?"}
+    ]
+    
+    response = tool_client.chat(
+        messages,
+        timeout=30.0,
+    )
+    logger.info("Received response from model")
+    print("\nResponse for New York weather:")
+    print(response)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main()) 

{mbxai-0.7.3 → mbxai-0.8.1}/src/mbxai/mcp/client.py

@@ -60,7 +60,7 @@ class MCPClient(ToolClient):
 
     def _create_tool_function(self, tool: MCPTool) -> Callable[..., Any]:
         """Create a function that invokes an MCP tool."""
-        async def tool_function(**kwargs: Any) -> Any:
+        def tool_function(**kwargs: Any) -> Any:
             # If kwargs has input wrapper, unwrap it
             if "input" in kwargs:
                 kwargs = kwargs["input"]
@@ -75,7 +75,7 @@ class MCPClient(ToolClient):
                 url = f"{server_url}/tools/{tool.name}/invoke"
 
             # Make the HTTP request to the tool's URL
-            response = await self._http_client.post(
+            response = self._http_client.post(
                 url,
                 json={"input": kwargs} if tool.strict else kwargs,
                 timeout=300.0  # 5 minutes timeout

{mbxai-0.7.3 → mbxai-0.8.1}/src/mbxai/mcp/server.py

@@ -31,7 +31,7 @@ class MCPServer:
         self.app = FastAPI(
             title=self.name,
             description=self.description,
-            version="0.7.3",
+            version="0.8.1",
         )
         
         # Initialize MCP server

{mbxai-0.7.3 → mbxai-0.8.1}/src/mbxai/openrouter/client.py

@@ -4,7 +4,6 @@ OpenRouter client implementation.
 
 from typing import Any, Optional, Union
 from openai import OpenAI, OpenAIError
-from pydantic import BaseModel, TypeAdapter, Field
 from .models import OpenRouterModel, OpenRouterModelRegistry
 from .config import OpenRouterConfig
 import logging
@@ -95,7 +94,7 @@ class OpenRouterClient:
     def __init__(
         self,
         token: str,
-        model: Union[str, OpenRouterModel] = OpenRouterModel.GPT4_TURBO,
+        model: Union[str, OpenRouterModel] = OpenRouterModel.GPT35_TURBO,
         base_url: Optional[str] = None,
         default_headers: Optional[dict[str, str]] = None,
         max_retries: int = 3,
@@ -106,7 +105,7 @@ class OpenRouterClient:
 
         Args:
             token: The OpenRouter API token
-            model: The model to use (default: GPT4_TURBO)
+            model: The model to use (default: GPT35_TURBO)
             base_url: Optional custom base URL for the API
             default_headers: Optional default headers for API requests
             max_retries: Maximum number of retry attempts (default: 3)
@@ -187,7 +186,7 @@ class OpenRouterClient:
         self.model = value
 
     @with_retry()
-    def chat_completion(
+    def create(
         self,
         messages: list[dict[str, Any]],
         *,
@@ -205,21 +204,15 @@ class OpenRouterClient:
             total_size = sum(len(str(msg)) for msg in messages)
             logger.info(f"Total message size: {total_size} bytes")
             
-            response = self._client.responses.create(
-                input=messages,
-                model=model or self.model,
-                stream=stream,
+            request = {
+                "model": model or self.model,
+                "messages": messages,
+                "stream": stream,
                 **kwargs,
-            )
+            }
             
-            # Log response details
-            logger.info("Received response from OpenRouter")
-            # Log the actual response content
-            logger.info(f"Response content: {response}")
-            if hasattr(response, 'output'):
-                logger.info(f"Response output length: {len(response.output) if response.output else 0}")
-            if hasattr(response, 'output_text'):
-                logger.info(f"Response output_text length: {len(response.output_text) if response.output_text else 0}")
+            response = self._client.chat.completions.create(**request)
+            logger.info(f"Received response from OpenRouter: {len(response.choices)} choices")
             
             return response
             
@@ -237,31 +230,15 @@ class OpenRouterClient:
             self._handle_api_error("chat completion", e)
 
     @with_retry()
-    def chat_completion_parse(
+    def parse(
         self,
         messages: list[dict[str, Any]],
-        response_format: type[BaseModel],
+        response_format: object,
         *,
-        model: Optional[Union[str, OpenRouterModel]] = None,
+        model: str | None = None,
         **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
-            **kwargs: Additional parameters
-
-        Returns:
-            Parsed completion response with output and output_parsed fields
-
-        Raises:
-            OpenRouterConnectionError: For connection issues
-            OpenRouterAPIError: For API errors
-            OpenRouterError: For other errors
-            ValueError: If response parsing fails
-        """
+        """Get a chat completion from OpenRouter."""
         try:
             # Log the request details
             logger.info(f"Sending chat completion request to OpenRouter with model: {model or self.model}")
@@ -271,26 +248,15 @@ class OpenRouterClient:
             total_size = sum(len(str(msg)) for msg in messages)
             logger.info(f"Total message size: {total_size} bytes")
             
-            # Use responses.parse for structured output
-            response = self._client.responses.parse(
-                model=model or self.model,
-                input=messages,
-                text_format=response_format,
+            request = {
+                "model": model or self.model,
+                "messages": messages,
+                "response_format": response_format,
                 **kwargs,
-            )
-            
-            if not response:
-                logger.error(f"Full response content: {response}")
-                raise OpenRouterAPIError("Invalid response from OpenRouter: empty response")
+            }
             
-            # Log response details
-            logger.info("Received response from OpenRouter")
-            if hasattr(response, 'output'):
-                logger.info(f"Response output length: {len(response.output) if response.output else 0}")
-            if hasattr(response, 'output_parsed'):
-                logger.info("Response includes parsed output")
-            if hasattr(response, 'tool_calls'):
-                logger.info(f"Response includes {len(response.tool_calls)} tool calls")
+            response = self._client.beta.chat.completions.parse(**request)
+            logger.info(f"Received response from OpenRouter: {len(response.choices)} choices")
             
             return response
             
@@ -307,45 +273,6 @@ class OpenRouterClient:
                     logger.error("Could not read response content")
             self._handle_api_error("chat completion", e)
 
-    @with_retry()
-    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.