mbxai 0.8.1__tar.gz → 0.8.3__tar.gz

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

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

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

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

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

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

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

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

mbxai-0.8.3/src/mbxai/examples/mcp/mcp_client_example.py

@@ -0,0 +1,76 @@
+"""Example usage of the MCP client."""
+
+import logging
+import os
+from mbxai.openrouter import OpenRouterClient
+from mbxai.mcp import MCPClient
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def main():
+    # Get API key from environment variable
+    api_key = os.getenv("OPENROUTER_API_KEY")
+    if not api_key:
+        logger.error("Please set the OPENROUTER_API_KEY environment variable")
+        return
+
+    try:
+        # Initialize the OpenRouter client (required by MCPClient)
+        openrouter_client = OpenRouterClient(token=api_key)
+        
+        # Create MCP client
+        with MCPClient(openrouter_client) as client:
+            # Register the local MCP server
+            server_url = "http://localhost:8000"
+            try:
+                client.register_mcp_server("mcp_server", server_url)
+            except Exception as e:
+                logger.error(f"Failed to register MCP server: {str(e)}")
+                logger.error("Make sure the MCP server is running at http://localhost:8000")
+                return
+            
+            # Test chat with tool calls
+            messages = [
+                {
+                    "role": "user",
+                    "content": "Scrape this example url: https://www.google.com"
+                }
+            ]
+            
+            try:
+                # Get the chat response
+                response = client.chat(messages=messages)
+                
+                # Print the final response
+                if not response:
+                    logger.error("No response received from the model")
+                    return
+                    
+                if not hasattr(response, 'choices'):
+                    logger.error(f"Invalid response format - no choices attribute: {response}")
+                    return
+                    
+                if not response.choices:
+                    logger.error("No choices in response")
+                    return
+                    
+                final_message = response.choices[0].message
+                if not final_message:
+                    logger.error("No message in first choice")
+                    return
+                    
+                logger.info(f"Final response: {final_message.content}")
+                    
+            except Exception as e:
+                logger.error(f"Error during chat: {str(e)}")
+                if hasattr(e, 'response'):
+                    logger.error(f"Response status: {e.response.status_code if e.response else 'No response'}")
+                    logger.error(f"Response content: {e.response.text if e.response else 'No content'}")
+                
+    except Exception as e:
+        logger.error(f"Error initializing clients: {str(e)}")
+
+if __name__ == "__main__":
+    main() 

mbxai-0.8.3/src/mbxai/examples/mcp/mcp_server_example.py

@@ -0,0 +1,94 @@
+"""Example MCP server implementation."""
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import uvicorn
+from typing import Any
+
+app = FastAPI()
+
+class ScraperInput(BaseModel):
+    url: str
+
+class ScrapeHtmlArguments(BaseModel):
+    input: ScraperInput
+
+
+@app.get("/tools")
+async def get_tools():
+    """Return the list of available tools."""
+    return {
+        "tools": [
+            {
+                "description": "Scrape HTML content from a URL.\n\n    This function fetches the HTML content from a given URL using httpx.\n    It handles redirects and raises appropriate exceptions for HTTP errors.\n\n    Args:\n        input (ScrapeHtmlInput): The input containing the URL to scrape\n\n    Returns:\n        ScrapeHtmlOutput: The HTML content of the page\n\n    Raises:\n        httpx.HTTPError: If there's an HTTP error while fetching the page\n        Exception: For any other unexpected errors\n    ",
+                "input_schema": {
+                    "$defs": {
+                        "ScrapeHtmlInput": {
+                            "properties": {
+                                "url": {
+                                    "description": "The URL to scrape HTML from",
+                                    "minLength": 1,
+                                    "title": "Url",
+                                    "type": "string",
+                                }
+                            },
+                            "required": ["url"],
+                            "title": "ScrapeHtmlInput",
+                            "type": "object",
+                        }
+                    },
+                    "properties": {"input": {"$ref": "#/$defs/ScrapeHtmlInput"}},
+                    "required": ["input"],
+                    "title": "scrape_htmlArguments",
+                    "type": "object",
+                },
+                "internal_url": "http://localhost:8000/tools/scrape_html/invoke",
+                "name": "scrape_html",
+                "service": "html-structure-analyser",
+                "strict": True,
+            }
+        ]
+    }
+
+
+@app.post("/tools/scrape_html/invoke")
+async def scrape_html(arguments: ScrapeHtmlArguments):
+    sample_html = """
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Sample Page</title>
+    </head>
+    <body>
+        <header>
+            <h1>Welcome to Sample Page</h1>
+            <nav>
+                <ul>
+                    <li><a href="#home">Home</a></li>
+                    <li><a href="#about">About</a></li>
+                    <li><a href="#contact">Contact</a></li>
+                </ul>
+            </nav>
+        </header>
+        <main>
+            <section id="content">
+                <h2>Main Content</h2>
+                <p>This is a sample HTML page that was scraped from {arguments.input.url}</p>
+                <article>
+                    <h3>Article Title</h3>
+                    <p>This is a sample article with some content.</p>
+                </article>
+            </section>
+        </main>
+        <footer>
+            <p>&copy; 2024 Sample Website</p>
+        </footer>
+    </body>
+    </html>
+    """
+    return sample_html
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000) 

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

@@ -3,7 +3,6 @@
 from typing import Any, TypeVar, Callable
 import httpx
 import logging
-import asyncio
 import json
 from pydantic import BaseModel, Field
 
@@ -48,15 +47,15 @@ class MCPClient(ToolClient):
         """Initialize the MCP client."""
         super().__init__(openrouter_client)
         self._mcp_servers: dict[str, str] = {}
-        self._http_client = httpx.AsyncClient()
+        self._http_client = httpx.Client()
 
-    async def __aenter__(self):
-        """Enter the async context."""
+    def __enter__(self):
+        """Enter the context."""
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Exit the async context."""
-        await self._http_client.aclose()
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit the context."""
+        self._http_client.close()
 
     def _create_tool_function(self, tool: MCPTool) -> Callable[..., Any]:
         """Create a function that invokes an MCP tool."""
@@ -96,12 +95,12 @@ class MCPClient(ToolClient):
         
         return tool_function
 
-    async def register_mcp_server(self, name: str, base_url: str) -> None:
+    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")
+        response = self._http_client.get(f"{base_url}/tools")
         response_data = response.json()
         
         # Extract tools array from response

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

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

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

@@ -212,6 +212,9 @@ class OpenRouterClient:
             }
             
             response = self._client.chat.completions.create(**request)
+            
+            logger.info(f"Response: {response}")
+            
             logger.info(f"Received response from OpenRouter: {len(response.choices)} choices")
             
             return response

{mbxai-0.8.1 → mbxai-0.8.3}/src/mbxai/tools/types.py

@@ -21,19 +21,16 @@ def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True, keep_i
         A schema in strict format
     """
     if not schema:
-        return {"type": "object", "properties": {}, "required": []}
+        return {"type": "object", "properties": {}, "required": [], "additionalProperties": False}
 
     # Create a new schema object to ensure we have all required fields
     strict_schema = {
         "type": "object",
         "properties": {},
-        "required": []
+        "required": [],
+        "additionalProperties": False  # Always enforce additionalProperties: false for OpenRouter
     }
 
-    # Add additionalProperties: false for strict validation
-    if strict:
-        strict_schema["additionalProperties"] = False
-
     # Handle input wrapper
     if "properties" in schema and "input" in schema["properties"]:
         input_schema = schema["properties"]["input"]
@@ -48,13 +45,10 @@ def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True, keep_i
             input_prop_schema = {
                 "type": "object",
                 "properties": {},
-                "required": []
+                "required": [],
+                "additionalProperties": False  # Always enforce additionalProperties: false for OpenRouter
             }
             
-            # Add additionalProperties: false for input schema
-            if strict:
-                input_prop_schema["additionalProperties"] = False
-            
             # Copy over input properties
             if "properties" in input_schema:
                 for prop_name, prop in input_schema["properties"].items():
@@ -64,6 +58,10 @@ def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True, keep_i
                         "description": prop.get("description", f"The {prop_name} parameter")
                     }
                     
+                    # If the property is an object, ensure it has additionalProperties: false
+                    if new_prop["type"] == "object":
+                        new_prop["additionalProperties"] = False
+                    
                     input_prop_schema["properties"][prop_name] = new_prop
             
             # Copy over required fields for input schema
@@ -86,6 +84,10 @@ def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True, keep_i
                         "description": prop.get("description", f"The {prop_name} parameter")
                     }
                     
+                    # If the property is an object, ensure it has additionalProperties: false
+                    if new_prop["type"] == "object":
+                        new_prop["additionalProperties"] = False
+                    
                     strict_schema["properties"][prop_name] = new_prop
             
             # Copy over required fields
@@ -101,6 +103,10 @@ def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True, keep_i
                     "description": prop.get("description", f"The {prop_name} parameter")
                 }
                 
+                # If the property is an object, ensure it has additionalProperties: false
+                if new_prop["type"] == "object":
+                    new_prop["additionalProperties"] = False
+                
                 strict_schema["properties"][prop_name] = new_prop
         
         # Copy over required fields