mcp-ollama-python 1.0.1__py3-none-any.whl

mcp_ollama_python/__init__.py

@@ -0,0 +1 @@
+__all__ = ["main"]

mcp_ollama_python/__main__.py

@@ -0,0 +1,8 @@
+"""
+Entry point for running as: python -m mcp_ollama_python
+"""
+
+from .main import run
+
+if __name__ == "__main__":
+    run()

mcp_ollama_python/autoloader.py

@@ -0,0 +1,97 @@
+"""
+Tool autoloader - dynamically discovers and loads tools from the tools directory
+"""
+
+import importlib
+import os
+import pkgutil
+from typing import List, Callable, Any, Dict
+
+try:
+    from mcp_ollama_python.ollama_client import OllamaClient
+    from mcp_ollama_python.models import ToolDefinition, ResponseFormat
+except ImportError:
+    from .ollama_client import OllamaClient
+    from .models import ToolDefinition, ResponseFormat
+
+# Type for tool handler function
+ToolHandler = Callable[[OllamaClient, Dict[str, Any], ResponseFormat], str]
+
+
+class ToolRegistry:
+    """Registry for tool definitions and their handlers"""
+
+    def __init__(self):
+        self.tools: List[ToolDefinition] = []
+        self.handlers: Dict[str, ToolHandler] = {}
+
+    def register(self, tool_def: ToolDefinition, handler: ToolHandler):
+        """Register a tool definition with its handler"""
+        self.tools.append(tool_def)
+        self.handlers[tool_def.name] = handler
+
+    def get_handler(self, tool_name: str) -> ToolHandler:
+        """Get handler for a tool by name"""
+        return self.handlers.get(tool_name)
+
+
+async def discover_tools() -> List[ToolDefinition]:
+    """Discover and load all tools from the tools directory (backward compatibility)"""
+    registry = await discover_tools_with_handlers()
+    return registry.tools
+
+
+async def discover_tools_with_handlers() -> ToolRegistry:
+    """Discover and load all tools with their handlers from the tools directory"""
+
+    registry = ToolRegistry()
+
+    # Get the tools package path
+    tools_package = importlib.import_module(".tools", package="mcp_ollama_python")
+
+    # Get the directory path
+    if hasattr(tools_package, "__path__"):
+        tools_dir = tools_package.__path__[0]
+    else:
+        # Fallback for different Python versions
+        tools_dir = os.path.dirname(tools_package.__file__)
+
+    # Iterate through all Python files in the tools directory
+    for _, module_name, _ in pkgutil.iter_modules([tools_dir]):
+        if module_name.startswith("__"):
+            continue
+
+        try:
+            # Import the module
+            module = importlib.import_module(
+                f".tools.{module_name}", package="mcp_ollama_python"
+            )
+
+            # Check if module exports tool_definition
+            if hasattr(module, "tool_definition"):
+                tool_def = getattr(module, "tool_definition")
+
+                # Convert dict to ToolDefinition if needed
+                if isinstance(tool_def, dict):
+                    tool_def = ToolDefinition(**tool_def)
+
+                if isinstance(tool_def, ToolDefinition):
+                    # Find the handler function (should end with _handler)
+                    handler = None
+                    for attr_name in dir(module):
+                        if attr_name.endswith("_handler") and callable(
+                            getattr(module, attr_name)
+                        ):
+                            handler = getattr(module, attr_name)
+                            break
+
+                    if handler:
+                        registry.register(tool_def, handler)
+                    else:
+                        print(f"Warning: Tool {tool_def.name} has no handler function")
+
+        except Exception as e:
+            print(f"Warning: Failed to load tool {module_name}: {e}")
+            continue
+
+    return registry

mcp_ollama_python/examples/get_spanish_poem.py

@@ -0,0 +1,59 @@
+"""
+Get a Spanish poem using local MCP Ollama server with gpt-oss model
+"""
+
+import asyncio
+import json
+from mcp_ollama_python.ollama_client import OllamaClient
+from mcp_ollama_python.models import ChatMessage
+
+
+async def get_spanish_poem():
+    """Generate a Spanish poem using gpt-oss model"""
+    print("Connecting to Ollama server...")
+    client = OllamaClient()
+
+    print("Requesting Spanish poem from gpt-oss model...")
+
+    # Create chat message
+    messages = [
+        ChatMessage(
+            role="user",
+            content="Escribe un poema bonito en español sobre la vida, el amor y la esperanza. Hazlo corto pero emotivo.",
+        )
+    ]
+
+    try:
+        # Call Ollama chat API
+        result = await client.chat(model="gpt-oss", messages=messages)
+
+        # Extract the response
+        if result and "message" in result:
+            poem = result["message"].get("content", "")
+            print("\n" + "=" * 60)
+            print("POEMA EN ESPAÑOL (Spanish Poem)")
+            print("=" * 60)
+            print(poem)
+            print("=" * 60)
+            return poem
+        else:
+            print("Error: No response received")
+            print(f"Result: {json.dumps(result, indent=2)}")
+            return None
+    except Exception as e:
+        print(f"Error calling Ollama: {e}")
+        return None
+    finally:
+        await client.client.aclose()
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(get_spanish_poem())
+    except KeyboardInterrupt:
+        print("\n\nInterrupted by user")
+    except Exception as e:
+        print(f"\nError: {e}")
+        import traceback
+
+        traceback.print_exc()

mcp_ollama_python/main.py

@@ -0,0 +1,214 @@
+"""
+Ollama MCP Server - Main entry point
+"""
+
+import asyncio
+import signal
+import sys
+from typing import Optional
+
+# Use absolute imports so PyInstaller/standalone execution works even when __package__ is not set
+try:
+    from mcp_ollama_python.server import OllamaMCPServer
+    from mcp_ollama_python.ollama_client import OllamaClient
+except ImportError:
+    from .server import OllamaMCPServer
+    from .ollama_client import OllamaClient
+
+try:
+    from mcp.server import Server
+    from mcp.types import (
+        TextContent,
+        Tool as MCPTool,
+        Resource,
+        Prompt,
+    )
+    from mcp.server.stdio import stdio_server
+except ImportError as e:
+    print(f"Error: mcp package import failed: {e}")
+    print("Please install it with: pip install mcp")
+    sys.exit(1)
+
+
+# Global server instance for signal handling
+_server_instance: Optional[Server] = None
+_shutdown_event: Optional[asyncio.Event] = None
+
+
+def safe_print(*args, **kwargs):
+    """Safe print that handles closed stdout/stderr"""
+    try:
+        print(*args, **kwargs)
+    except (ValueError, OSError):
+        # stdout/stderr is closed, ignore
+        pass
+
+
+def signal_handler(signum, frame):
+    """Handle shutdown signals gracefully"""
+    safe_print(f"\nReceived signal {signum}, shutting down gracefully...")
+    if _shutdown_event:
+        _shutdown_event.set()
+
+
+async def main():
+    """Main function to start the MCP server"""
+    global _server_instance, _shutdown_event
+
+    # Create shutdown event
+    _shutdown_event = asyncio.Event()
+
+    # Register signal handlers for graceful shutdown
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    # Initialize Ollama client
+    ollama_client = OllamaClient()
+
+    # Initialize our MCP server
+    server = OllamaMCPServer(ollama_client)
+
+    # Create MCP server instance
+    mcp_server = Server("ollama-mcp")
+    _server_instance = mcp_server
+
+    safe_print("Starting Ollama MCP Server...")
+    safe_print("Press Ctrl+C to stop the server")
+
+    @mcp_server.list_tools()
+    async def handle_list_tools() -> list[MCPTool]:
+        """Handle list_tools request"""
+        result = await server.handle_list_tools()
+        tools = []
+        for tool_data in result["tools"]:
+            tools.append(
+                MCPTool(
+                    name=tool_data["name"],
+                    description=tool_data["description"],
+                    inputSchema=tool_data["inputSchema"],
+                )
+            )
+        return tools
+
+    @mcp_server.call_tool()
+    async def handle_call_tool(name: str, arguments: dict) -> list[TextContent]:
+        """Handle call_tool request"""
+        result = await server.handle_call_tool(name, arguments)
+
+        content = []
+        for item in result["content"]:
+            if item["type"] == "text":
+                content.append(TextContent(type="text", text=item["text"]))
+
+        return content
+
+    @mcp_server.list_resources()
+    async def handle_list_resources() -> list[Resource]:
+        """Handle list_resources request"""
+        result = await server.handle_list_resources()
+        resources = []
+        for resource_data in result["resources"]:
+            resources.append(
+                Resource(
+                    uri=resource_data["uri"],
+                    name=resource_data["name"],
+                    description=resource_data.get("description"),
+                    mimeType=resource_data.get("mimeType", "text/plain"),
+                )
+            )
+        return resources
+
+    @mcp_server.read_resource()
+    async def handle_read_resource(uri: str) -> str:
+        """Handle read_resource request"""
+        result = await server.handle_read_resource(uri)
+        if result.get("contents"):
+            return result["contents"][0].get("text", "")
+        return ""
+
+    @mcp_server.list_prompts()
+    async def handle_list_prompts() -> list[Prompt]:
+        """Handle list_prompts request"""
+        result = await server.handle_list_prompts()
+        prompts = []
+        for prompt_data in result["prompts"]:
+            prompts.append(
+                Prompt(
+                    name=prompt_data["name"],
+                    description=prompt_data.get("description"),
+                    arguments=prompt_data.get("arguments", []),
+                )
+            )
+        return prompts
+
+    @mcp_server.get_prompt()
+    async def handle_get_prompt(name: str, arguments: Optional[dict] = None) -> dict:
+        """Handle get_prompt request"""
+        result = await server.handle_get_prompt(name, arguments)
+        return result
+
+    # Run the server with graceful shutdown support
+    try:
+        async with stdio_server() as (read_stream, write_stream):
+            safe_print("Server started successfully!")
+            safe_print("Waiting for MCP client connections...")
+
+            # Create server task
+            server_task = asyncio.create_task(
+                mcp_server.run(
+                    read_stream,
+                    write_stream,
+                    mcp_server.create_initialization_options(),
+                )
+            )
+
+            # Wait for either server completion or shutdown signal
+            shutdown_task = asyncio.create_task(_shutdown_event.wait())
+            done, pending = await asyncio.wait(
+                [server_task, shutdown_task], return_when=asyncio.FIRST_COMPLETED
+            )
+
+            # Cancel pending tasks
+            for task in pending:
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    pass
+
+            safe_print("Server stopped.")
+
+    except KeyboardInterrupt:
+        safe_print("\nServer interrupted by user")
+    except Exception as e:
+        safe_print(f"Server error: {e}")
+        raise
+    finally:
+        # Cleanup
+        await ollama_client.client.aclose()
+        safe_print("Cleanup completed.")
+
+
+def run():
+    """Entry point for the mcp-ollama-python command"""
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        safe_print("\nShutdown complete.")
+        sys.exit(0)
+    except Exception as e:
+        safe_print(f"Fatal error: {e}")
+        sys.exit(1)
+
+
+def stop():
+    """Stop the running server (for programmatic control)"""
+    if _shutdown_event:
+        _shutdown_event.set()
+        safe_print("Stop signal sent to server")
+    else:
+        safe_print("No server instance running")
+
+
+if __name__ == "__main__":
+    run()

mcp_ollama_python/models.py

@@ -0,0 +1,119 @@
+"""
+Core types and enums for Ollama MCP Server
+"""
+
+from enum import Enum
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+
+
+class ResponseFormat(str, Enum):
+    """Response format for tool outputs"""
+
+    MARKDOWN = "markdown"
+    JSON = "json"
+
+
+class GenerationOptions(BaseModel):
+    """Generation options that can be passed to Ollama models"""
+
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    num_predict: Optional[int] = None
+    repeat_penalty: Optional[float] = None
+    seed: Optional[int] = None
+    stop: Optional[List[str]] = None
+
+
+class MessageRole(str, Enum):
+    """Message role for chat"""
+
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+
+
+class ChatMessage(BaseModel):
+    """Chat message structure"""
+
+    role: MessageRole
+    content: str
+    images: Optional[List[str]] = None
+    tool_calls: Optional[List["ToolCall"]] = None
+
+
+class Tool(BaseModel):
+    """Tool definition for function calling"""
+
+    type: str
+    function: Dict[str, Any]
+
+
+class ToolCall(BaseModel):
+    """Tool call made by the model"""
+
+    function: Dict[str, Any]
+
+
+class ToolDefinition(BaseModel):
+    """Represents a tool's metadata and handler function"""
+
+    name: str
+    description: str
+    input_schema: Dict[str, Any] = Field(
+        default_factory=lambda: {"type": "object", "properties": {}}
+    )
+
+
+class ToolContext(BaseModel):
+    """Base tool context passed to all tool implementations"""
+
+    pass  # In Python, we'll use dependency injection
+
+
+class ToolResult(BaseModel):
+    """Tool result with content and format"""
+
+    content: str
+    format: ResponseFormat
+
+
+# Error types
+class OllamaError(Exception):
+    """Base error for Ollama operations"""
+
+    def __init__(self, message: str, cause: Optional[Exception] = None):
+        super().__init__(message)
+        self.cause = cause
+
+
+class ModelNotFoundError(OllamaError):
+    """Error when a model is not found"""
+
+    def __init__(self, model_name: str):
+        super().__init__(
+            f"Model not found: {model_name}. Use ollama_list to see available models."
+        )
+
+
+class NetworkError(OllamaError):
+    """Network-related error"""
+
+    pass
+
+
+class WebSearchResult(BaseModel):
+    """Web search result"""
+
+    title: str
+    url: str
+    content: str
+
+
+class WebFetchResult(BaseModel):
+    """Web fetch result"""
+
+    title: str
+    content: str
+    links: List[str]

mcp_ollama_python/ollama_client.py

@@ -0,0 +1,169 @@
+"""
+Ollama HTTP client wrapper
+"""
+
+import os
+import httpx
+from typing import Any, Dict, List, Optional, Union
+
+try:
+    from mcp_ollama_python.models import (
+        GenerationOptions,
+        ChatMessage,
+        Tool,
+        OllamaError,
+        NetworkError,
+    )
+except ImportError:
+    from .models import GenerationOptions, ChatMessage, Tool, OllamaError, NetworkError
+
+
+class OllamaClient:
+    """HTTP client for Ollama API"""
+
+    def __init__(self, host: Optional[str] = None, api_key: Optional[str] = None):
+        self.host = host or os.getenv("OLLAMA_HOST", "http://127.0.0.1:11434")
+        self.api_key = api_key or os.getenv("OLLAMA_API_KEY")
+
+        # Create httpx client
+        headers = {}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        self.client = httpx.AsyncClient(
+            base_url=self.host,
+            headers=headers,
+            timeout=300.0,  # 5 minute timeout
+            follow_redirects=True,  # Follow HTTP redirects (301, 302, etc.)
+        )
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.client.aclose()
+
+    async def _get(self, endpoint: str) -> Dict[str, Any]:
+        """Make a GET request to Ollama API"""
+        try:
+            response = await self.client.get(endpoint)
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            raise OllamaError(
+                f"Ollama API error: {e.response.status_code} - {e.response.text}",
+                cause=e,
+            ) from e
+        except Exception as e:
+            raise NetworkError(f"Failed to connect to Ollama: {str(e)}", cause=e) from e
+
+    async def _post(self, endpoint: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Make a POST request to Ollama API"""
+        try:
+            response = await self.client.post(endpoint, json=data)
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            raise OllamaError(
+                f"Ollama API error: {e.response.status_code} - {e.response.text}",
+                cause=e,
+            ) from e
+        except OllamaError:
+            raise
+        except Exception as e:
+            raise NetworkError(f"Failed to connect to Ollama: {str(e)}", cause=e) from e
+
+    async def _delete(self, endpoint: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Make a DELETE request to Ollama API"""
+        try:
+            response = await self.client.request("DELETE", endpoint, json=data)
+            response.raise_for_status()
+            # DELETE may return empty body on success
+            if response.headers.get("content-length") == "0" or not response.content:
+                return {"status": "success"}
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            raise OllamaError(
+                f"Ollama API error: {e.response.status_code} - {e.response.text}",
+                cause=e,
+            ) from e
+        except OllamaError:
+            raise
+        except Exception as e:
+            raise NetworkError(f"Failed to connect to Ollama: {str(e)}", cause=e) from e
+
+    async def list(self) -> Dict[str, Any]:
+        """List all available models"""
+        return await self._get("/api/tags")
+
+    async def show(self, model: str) -> Dict[str, Any]:
+        """Show model information"""
+        return await self._post("/api/show", {"name": model})
+
+    async def pull(self, model: str) -> Dict[str, Any]:
+        """Pull a model"""
+        return await self._post("/api/pull", {"name": model, "stream": False})
+
+    async def push(self, model: str) -> Dict[str, Any]:
+        """Push a model"""
+        return await self._post("/api/push", {"name": model, "stream": False})
+
+    async def copy(self, source: str, destination: str) -> Dict[str, Any]:
+        """Copy a model"""
+        return await self._post(
+            "/api/copy", {"source": source, "destination": destination}
+        )
+
+    async def delete(self, model: str) -> Dict[str, Any]:
+        """Delete a model"""
+        return await self._delete("/api/delete", {"name": model})
+
+    async def create(
+        self, name: str, modelfile: str, stream: bool = False
+    ) -> Dict[str, Any]:
+        """Create a model from Modelfile"""
+        data = {"name": name, "modelfile": modelfile}
+        if stream:
+            data["stream"] = True
+        return await self._post("/api/create", data)
+
+    async def generate(
+        self,
+        model: str,
+        prompt: str,
+        options: Optional[GenerationOptions] = None,
+        stream: bool = False,
+    ) -> Dict[str, Any]:
+        """Generate text"""
+        data = {"model": model, "prompt": prompt, "stream": stream}
+        if options:
+            data["options"] = options.model_dump(exclude_unset=True)
+        return await self._post("/api/generate", data)
+
+    async def chat(
+        self,
+        model: str,
+        messages: List[ChatMessage],
+        tools: Optional[List[Tool]] = None,
+        options: Optional[GenerationOptions] = None,
+        stream: bool = False,
+    ) -> Dict[str, Any]:
+        """Chat with a model"""
+        data = {
+            "model": model,
+            "messages": [msg.model_dump(exclude_unset=True) for msg in messages],
+            "stream": stream,
+        }
+        if tools:
+            data["tools"] = [tool.model_dump() for tool in tools]
+        if options:
+            data["options"] = options.model_dump(exclude_unset=True)
+        return await self._post("/api/chat", data)
+
+    async def embed(self, model: str, input: Union[str, List[str]]) -> Dict[str, Any]:
+        """Generate embeddings"""
+        return await self._post("/api/embed", {"model": model, "input": input})
+
+    async def ps(self) -> Dict[str, Any]:
+        """List running models"""
+        return await self._get("/api/ps")