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

mcp_ollama_python/response_formatter.py

@@ -0,0 +1,120 @@
+"""
+Response formatting utilities
+"""
+
+import json
+from typing import Any, Dict, List
+
+try:
+    from mcp_ollama_python.models import ResponseFormat
+except ImportError:
+    from .models import ResponseFormat
+
+
+def format_response(content: Any, format: ResponseFormat) -> str:
+    """Format response content based on the specified format"""
+    # Handle dict/list input - convert to JSON string first
+    if isinstance(content, (dict, list)):
+        if format == ResponseFormat.JSON:
+            return json.dumps(content, indent=2)
+        else:
+            # Format as markdown
+            return json_to_markdown(content)
+
+    # Handle string input
+    if format == ResponseFormat.JSON:
+        # For JSON format, validate and potentially wrap errors
+        try:
+            # Try to parse to validate it's valid JSON
+            json.loads(content)
+            return content
+        except json.JSONDecodeError:
+            # If not valid JSON, wrap in error object
+            return json.dumps(
+                {
+                    "error": "Invalid JSON content",
+                    "raw_content": content,
+                }
+            )
+
+    # Format as markdown
+    try:
+        data = json.loads(content)
+        return json_to_markdown(data)
+    except json.JSONDecodeError:
+        # If not valid JSON, return as-is
+        return content
+
+
+def json_to_markdown(data: Any, indent: str = "") -> str:
+    """Convert JSON data to markdown format"""
+    # Handle null/undefined
+    if data is None:
+        return f"{indent}_null_"
+
+    # Handle primitives
+    if not isinstance(data, (dict, list)):
+        return f"{indent}{str(data)}"
+
+    # Handle arrays
+    if isinstance(data, list):
+        if len(data) == 0:
+            return f"{indent}_empty array_"
+
+        # Check if array of objects with consistent keys (table format)
+        if len(data) > 0 and isinstance(data[0], dict) and data[0] is not None:
+            return array_to_markdown_table(data, indent)
+
+        # Array of primitives or mixed types
+        return "\n".join(f"{indent}- {json_to_markdown(item, '')}" for item in data)
+
+    # Handle objects
+    entries = list(data.items())
+    if len(entries) == 0:
+        return f"{indent}_empty object_"
+
+    return "\n".join(_format_object_entry(key, value, indent) for key, value in entries)
+
+
+def _format_object_entry(key: str, value: Any, indent: str) -> str:
+    """Format a single key-value pair in an object"""
+    formatted_key = key.replace("_", " ")
+    if isinstance(value, (dict, list)) and value is not None:
+        return f"{indent}**{formatted_key}:**\n{json_to_markdown(value, indent + '  ')}"
+    return f"{indent}**{formatted_key}:** {value}"
+
+
+def array_to_markdown_table(data: List[Dict[str, Any]], indent: str = "") -> str:
+    """Convert array of objects to markdown table format"""
+    if not data or not isinstance(data[0], dict):
+        return json_to_markdown(data, indent)
+
+    # Get all unique keys from all objects, preserving insertion order
+    all_keys = dict.fromkeys(
+        key for item in data if isinstance(item, dict) for key in item
+    )
+
+    if not all_keys:
+        return f"{indent}_empty array_"
+
+    headers = list(all_keys)
+    rows = []
+
+    # Add header row
+    header_row = "| " + " | ".join(headers) + " |"
+    separator_row = "|" + "|".join("---" for _ in headers) + "|"
+    rows.extend([header_row, separator_row])
+
+    # Add data rows
+    for item in data:
+        if isinstance(item, dict):
+            row_values = []
+            for header in headers:
+                value = item.get(header, "")
+                # Truncate long values for table display
+                if isinstance(value, str) and len(value) > 50:
+                    value = value[:47] + "..."
+                row_values.append(str(value))
+            rows.append("| " + " | ".join(row_values) + " |")
+
+    return "\n".join(rows)

mcp_ollama_python/server.py

@@ -0,0 +1,286 @@
+"""
+MCP Server implementation for Ollama
+"""
+
+import json
+from typing import Any, Dict, Optional
+
+try:
+    from mcp_ollama_python.ollama_client import OllamaClient
+    from mcp_ollama_python.autoloader import discover_tools_with_handlers, ToolRegistry
+    from mcp_ollama_python.models import ResponseFormat
+except ImportError:
+    from .ollama_client import OllamaClient
+    from .autoloader import discover_tools_with_handlers, ToolRegistry
+    from .models import ResponseFormat
+
+
+class OllamaMCPServer:
+    """MCP Server for Ollama operations"""
+
+    def __init__(self, ollama_client: Optional[OllamaClient] = None):
+        self.ollama_client = ollama_client or OllamaClient()
+        self.tool_registry: Optional[ToolRegistry] = None
+        self._resources: Dict[str, Dict[str, Any]] = {}
+        self._prompts: Dict[str, Dict[str, Any]] = {}
+        self._initialize_default_resources()
+        self._initialize_default_prompts()
+
+    async def handle_list_tools(self) -> Dict[str, Any]:
+        """Handle list_tools request"""
+        # Discover tools and cache the registry
+        if self.tool_registry is None:
+            self.tool_registry = await discover_tools_with_handlers()
+
+        return {
+            "tools": [
+                {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "inputSchema": tool.input_schema,
+                }
+                for tool in self.tool_registry.tools
+            ]
+        }
+
+    async def handle_call_tool(self, name: str, args: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle call_tool request"""
+        try:
+            # Ensure tool registry is loaded
+            if self.tool_registry is None:
+                self.tool_registry = await discover_tools_with_handlers()
+
+            # Get the handler for this tool
+            handler = self.tool_registry.get_handler(name)
+
+            if not handler:
+                raise ValueError(f"Unknown tool: {name}")
+
+            # Determine format from args
+            format_arg = args.get("format", "json")
+            response_format = (
+                ResponseFormat.MARKDOWN
+                if format_arg == "markdown"
+                else ResponseFormat.JSON
+            )
+
+            # Call the tool handler directly
+            result = await handler(self.ollama_client, args, response_format)
+
+            # Try to parse the result as JSON for structured content
+            structured_data = None
+            try:
+                structured_data = json.loads(result)
+            except (json.JSONDecodeError, TypeError):
+                pass
+
+            return {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": result,
+                    }
+                ],
+                "structuredContent": structured_data,
+            }
+
+        except Exception as error:
+            error_message = str(error) if isinstance(error, Exception) else str(error)
+            return {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": f"Error: {error_message}",
+                    }
+                ],
+                "isError": True,
+            }
+
+    def _initialize_default_resources(self):
+        """Initialize default resources for the MCP server"""
+        self._resources = {
+            "ollama://models": {
+                "uri": "ollama://models",
+                "name": "Available Models",
+                "description": "List of all available Ollama models",
+                "mimeType": "application/json",
+            },
+            "ollama://running": {
+                "uri": "ollama://running",
+                "name": "Running Models",
+                "description": "List of currently running models",
+                "mimeType": "application/json",
+            },
+            "ollama://config": {
+                "uri": "ollama://config",
+                "name": "Ollama Configuration",
+                "description": "Current Ollama server configuration",
+                "mimeType": "application/json",
+            },
+        }
+
+    def _initialize_default_prompts(self):
+        """Initialize default prompts for the MCP server"""
+        self._prompts = {
+            "explain_lora": {
+                "name": "explain_lora",
+                "description": "Explain LoRA (Low-Rank Adaptation) technique",
+                "arguments": [
+                    {
+                        "name": "detail_level",
+                        "description": "Level of detail: basic, intermediate, or advanced",
+                        "required": False,
+                    }
+                ],
+            },
+            "code_review": {
+                "name": "code_review",
+                "description": "Review code and provide feedback",
+                "arguments": [
+                    {
+                        "name": "language",
+                        "description": "Programming language",
+                        "required": True,
+                    },
+                    {
+                        "name": "focus",
+                        "description": "Focus areas: security, performance, style, or all",
+                        "required": False,
+                    },
+                ],
+            },
+            "hello_world": {
+                "name": "hello_world",
+                "description": "Generate Hello World code in any language",
+                "arguments": [
+                    {
+                        "name": "language",
+                        "description": "Programming language",
+                        "required": True,
+                    }
+                ],
+            },
+        }
+
+    async def handle_list_resources(self) -> Dict[str, Any]:
+        """Handle list_resources request"""
+        return {
+            "resources": [
+                {
+                    "uri": resource["uri"],
+                    "name": resource["name"],
+                    "description": resource["description"],
+                    "mimeType": resource.get("mimeType", "text/plain"),
+                }
+                for resource in self._resources.values()
+            ]
+        }
+
+    async def handle_read_resource(self, uri: str) -> Dict[str, Any]:
+        """Handle read_resource request"""
+        try:
+            if uri not in self._resources:
+                raise ValueError(f"Unknown resource: {uri}")
+
+            # Fetch the actual resource data
+            if uri == "ollama://models":
+                data = await self.ollama_client.list()
+                content = json.dumps(data, indent=2)
+            elif uri == "ollama://running":
+                data = await self.ollama_client.ps()
+                content = json.dumps(data, indent=2)
+            elif uri == "ollama://config":
+                config_data = {
+                    "host": self.ollama_client.host,
+                    "has_api_key": bool(self.ollama_client.api_key),
+                }
+                content = json.dumps(config_data, indent=2)
+            else:
+                content = "Resource data not available"
+
+            return {
+                "contents": [
+                    {
+                        "uri": uri,
+                        "mimeType": self._resources[uri].get("mimeType", "text/plain"),
+                        "text": content,
+                    }
+                ]
+            }
+
+        except Exception as error:
+            error_message = str(error) if isinstance(error, Exception) else str(error)
+            return {
+                "contents": [
+                    {
+                        "uri": uri,
+                        "mimeType": "text/plain",
+                        "text": f"Error reading resource: {error_message}",
+                    }
+                ],
+                "isError": True,
+            }
+
+    async def handle_list_prompts(self) -> Dict[str, Any]:
+        """Handle list_prompts request"""
+        return {
+            "prompts": [
+                {
+                    "name": prompt["name"],
+                    "description": prompt["description"],
+                    "arguments": prompt.get("arguments", []),
+                }
+                for prompt in self._prompts.values()
+            ]
+        }
+
+    async def handle_get_prompt(
+        self, name: str, arguments: Optional[Dict[str, str]] = None
+    ) -> Dict[str, Any]:
+        """Handle get_prompt request"""
+        try:
+            if name not in self._prompts:
+                raise ValueError(f"Unknown prompt: {name}")
+
+            prompt_def = self._prompts[name]
+            args = arguments or {}
+
+            # Generate prompt based on name
+            if name == "explain_lora":
+                detail = args.get("detail_level", "basic")
+                prompt_text = f"""Explain LoRA (Low-Rank Adaptation) at a {detail} level.
+Include:
+- What it is and why it's useful
+- How it works technically
+- Use cases and benefits
+- Comparison with full fine-tuning"""
+            elif name == "code_review":
+                language = args.get("language", "Python")
+                focus = args.get("focus", "all")
+                prompt_text = f"""Review the following {language} code with focus on {focus}.
+Provide:
+- Issues found
+- Suggestions for improvement
+- Best practices recommendations
+- Security concerns (if applicable)"""
+            elif name == "hello_world":
+                language = args.get("language", "Python")
+                prompt_text = f"""Write a complete, well-commented Hello World program in {language}.
+Include:
+- Proper syntax and structure
+- Comments explaining each part
+- Best practices for the language
+- How to run the program"""
+            else:
+                prompt_text = f"Prompt template for {name}"
+
+            return {
+                "description": prompt_def["description"],
+                "messages": [
+                    {"role": "user", "content": {"type": "text", "text": prompt_text}}
+                ],
+            }
+
+        except Exception as error:
+            error_message = str(error) if isinstance(error, Exception) else str(error)
+            raise ValueError(f"Error getting prompt: {error_message}")

mcp_ollama_python/tools/__init__.py

@@ -0,0 +1,6 @@
+"""
+Ollama MCP Tools Package
+"""
+
+# This file makes the tools directory a Python package
+# Tools are automatically discovered by the autoloader

mcp_ollama_python/tools/chat.py

@@ -0,0 +1,130 @@
+"""
+Ollama chat tool
+"""
+
+from typing import Dict, Any
+from ..models import (
+    ToolDefinition,
+    ResponseFormat,
+    ChatMessage,
+    Tool as OllamaTool,
+    GenerationOptions,
+    ModelNotFoundError,
+)
+from ..ollama_client import OllamaClient
+from ..response_formatter import format_response
+
+
+async def chat_handler(
+    ollama: OllamaClient, args: Dict[str, Any], format: ResponseFormat
+) -> str:
+    """Interactive chat with models (supports tools/functions)"""
+    model = args.get("model")
+    messages = args.get("messages")
+    tools = args.get("tools")
+    options = args.get("options")
+
+    if not model:
+        raise ValueError("Model name is required")
+    if not messages:
+        raise ValueError("Messages are required")
+
+    try:
+        # Convert messages to ChatMessage objects
+        chat_messages = []
+        for msg in messages:
+            chat_messages.append(ChatMessage(**msg))
+
+        # Convert tools if provided
+        chat_tools = None
+        if tools:
+            chat_tools = []
+            for tool in tools:
+                chat_tools.append(OllamaTool(**tool))
+
+        # Convert options if provided
+        gen_options = None
+        if options:
+            gen_options = GenerationOptions(**options)
+
+        result = await ollama.chat(model, chat_messages, chat_tools, gen_options)
+        return format_response(result, format)
+    except Exception as e:
+        if "model not found" in str(e).lower():
+            raise ModelNotFoundError(model)
+        raise
+
+
+# Tool definition
+tool_definition = ToolDefinition(
+    name="ollama_chat",
+    description="Interactive chat with Ollama models. Supports multi-turn conversations, tool calling, and structured outputs.",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "model": {
+                "type": "string",
+                "description": "Name of the model to use for chat",
+            },
+            "messages": {
+                "type": "array",
+                "description": "Array of chat messages",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "role": {
+                            "type": "string",
+                            "enum": ["system", "user", "assistant"],
+                        },
+                        "content": {
+                            "type": "string",
+                        },
+                        "images": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                        },
+                    },
+                    "required": ["role", "content"],
+                },
+            },
+            "tools": {
+                "type": "array",
+                "description": "Array of tools available to the model",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "type": {"type": "string"},
+                        "function": {
+                            "type": "object",
+                            "properties": {
+                                "name": {"type": "string"},
+                                "description": {"type": "string"},
+                                "parameters": {"type": "object"},
+                            },
+                        },
+                    },
+                },
+            },
+            "options": {
+                "type": "object",
+                "description": "Generation options (temperature, top_p, etc.)",
+                "properties": {
+                    "temperature": {"type": "number", "minimum": 0, "maximum": 2},
+                    "top_p": {"type": "number", "minimum": 0, "maximum": 1},
+                    "top_k": {"type": "integer", "minimum": 0},
+                    "num_predict": {"type": "integer", "minimum": 1},
+                    "repeat_penalty": {"type": "number", "minimum": 0},
+                    "seed": {"type": "integer"},
+                    "stop": {"type": "array", "items": {"type": "string"}},
+                },
+            },
+            "format": {
+                "type": "string",
+                "enum": ["json", "markdown"],
+                "description": "Output format (default: json)",
+                "default": "json",
+            },
+        },
+        "required": ["model", "messages"],
+    },
+)

mcp_ollama_python/tools/delete.py

@@ -0,0 +1,48 @@
+"""
+Ollama delete model tool
+"""
+
+from typing import Dict, Any
+from ..models import ToolDefinition, ResponseFormat, ModelNotFoundError
+from ..ollama_client import OllamaClient
+from ..response_formatter import format_response
+
+
+async def delete_handler(
+    ollama: OllamaClient, args: Dict[str, Any], format: ResponseFormat
+) -> str:
+    """Remove models from local storage"""
+    model = args.get("model")
+    if not model:
+        raise ValueError("Model name is required")
+
+    try:
+        result = await ollama.delete(model)
+        return format_response(result, format)
+    except Exception as e:
+        if "model not found" in str(e).lower() or "no such file" in str(e).lower():
+            raise ModelNotFoundError(model)
+        raise
+
+
+# Tool definition
+tool_definition = ToolDefinition(
+    name="ollama_delete",
+    description="Remove models from local Ollama storage to free up disk space.",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "model": {
+                "type": "string",
+                "description": "Name of the model to delete",
+            },
+            "format": {
+                "type": "string",
+                "enum": ["json", "markdown"],
+                "description": "Output format (default: json)",
+                "default": "json",
+            },
+        },
+        "required": ["model"],
+    },
+)

mcp_ollama_python/tools/embed.py

@@ -0,0 +1,63 @@
+"""
+Ollama embed tool
+"""
+
+from typing import Dict, Any
+from ..models import ToolDefinition, ResponseFormat, ModelNotFoundError
+from ..ollama_client import OllamaClient
+from ..response_formatter import format_response
+
+
+async def embed_handler(
+    ollama: OllamaClient, args: Dict[str, Any], format: ResponseFormat
+) -> str:
+    """Generate embeddings for text"""
+    model = args.get("model")
+    input_text = args.get("input")
+
+    if not model:
+        raise ValueError("Model name is required")
+    if not input_text:
+        raise ValueError("Input text is required")
+
+    try:
+        result = await ollama.embed(model, input_text)
+        return format_response(result, format)
+    except Exception as e:
+        if "model not found" in str(e).lower():
+            raise ModelNotFoundError(model)
+        raise
+
+
+# Tool definition
+tool_definition = ToolDefinition(
+    name="ollama_embed",
+    description="Generate vector embeddings for text using Ollama's embedding models like nomic-embed-text.",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "model": {
+                "type": "string",
+                "description": "Name of the embedding model (e.g., 'nomic-embed-text')",
+            },
+            "input": {
+                "oneOf": [
+                    {"type": "string", "description": "Single text string to embed"},
+                    {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Array of text strings to embed",
+                    },
+                ],
+                "description": "Text or array of texts to generate embeddings for",
+            },
+            "format": {
+                "type": "string",
+                "enum": ["json", "markdown"],
+                "description": "Output format (default: json)",
+                "default": "json",
+            },
+        },
+        "required": ["model", "input"],
+    },
+)