sunholo 0.141.1__py3-none-any.whl → 0.143.1__py3-none-any.whl

sunholo/agents/flask/vac_routes.py

@@ -6,6 +6,8 @@ import random
 from functools import partial
 import inspect
 import asyncio
+from typing import Dict, List, Optional, Callable, Any
+
 
 from ..chat_history import extract_chat_history_with_cache, extract_chat_history_async_cached
 from ...qna.parsers import parse_output
@@ -29,6 +31,21 @@ try:
 except ImportError:
     PubSubManager = None
 
+try:
+    from ...mcp.mcp_manager import MCPClientManager
+except ImportError:
+    MCPClientManager = None
+
+try:
+    from ...mcp.vac_mcp_server import VACMCPServer
+    from mcp.server.models import InitializationOptions
+    from mcp import JSONRPCMessage, ErrorData, INTERNAL_ERROR
+except ImportError:
+    VACMCPServer = None
+    InitializationOptions = None
+    JSONRPCMessage = None
+
+
 # Cache dictionary to store validated API keys
 api_key_cache = {}
 cache_duration = timedelta(minutes=5)  # Cache duration
@@ -61,11 +78,30 @@ if __name__ == "__main__":
                  stream_interpreter: callable, 
                  vac_interpreter:callable=None, 
                  additional_routes:dict=None, 
+                 mcp_servers: List[Dict[str, Any]] = None,
                  async_stream:bool=False,
-                 add_langfuse_eval:bool=True):
+                 add_langfuse_eval:bool=True,
+                 enable_mcp_server:bool=False):
         self.app = app
         self.stream_interpreter = stream_interpreter
         self.vac_interpreter = vac_interpreter or partial(self.vac_interpreter_default)
+
+        # MCP client initialization
+        self.mcp_servers = mcp_servers or []
+        self.mcp_client_manager = MCPClientManager()    
+        # Initialize MCP connections
+        if self.mcp_servers and self.mcp_client_manager:
+            asyncio.create_task(self._initialize_mcp_servers())
+
+        # MCP server initialization
+        self.enable_mcp_server = enable_mcp_server
+        self.vac_mcp_server = None
+        if self.enable_mcp_server and VACMCPServer:
+            self.vac_mcp_server = VACMCPServer(
+                stream_interpreter=self.stream_interpreter,
+                vac_interpreter=self.vac_interpreter
+            )
+
         self.additional_routes = additional_routes if additional_routes is not None else []
         self.async_stream = async_stream
         self.add_langfuse_eval = add_langfuse_eval
@@ -129,6 +165,18 @@ if __name__ == "__main__":
         # OpenAI compatible endpoint
         self.app.route('/openai/v1/chat/completions', methods=['POST'])(self.handle_openai_compatible_endpoint)
         self.app.route('/openai/v1/chat/completions/<vector_name>', methods=['POST'])(self.handle_openai_compatible_endpoint)
+
+        # MCP client routes
+        if self.mcp_servers:
+            self.app.route('/mcp/tools', methods=['GET'])(self.handle_mcp_list_tools)
+            self.app.route('/mcp/tools/<server_name>', methods=['GET'])(self.handle_mcp_list_tools)
+            self.app.route('/mcp/call', methods=['POST'])(self.handle_mcp_call_tool)
+            self.app.route('/mcp/resources', methods=['GET'])(self.handle_mcp_list_resources)
+            self.app.route('/mcp/resources/read', methods=['POST'])(self.handle_mcp_read_resource)
+        
+        # MCP server endpoint
+        if self.enable_mcp_server and self.vac_mcp_server:
+            self.app.route('/mcp', methods=['POST', 'GET'])(self.handle_mcp_server)
     
         self.register_additional_routes()
 
@@ -803,3 +851,254 @@ if __name__ == "__main__":
         except Exception as e:
             raise Exception(f'File upload failed: {str(e)}')
 
+    async def _initialize_mcp_servers(self):
+        """Initialize connections to configured MCP servers."""
+        for server_config in self.mcp_servers:
+            try:
+                await self.mcp_client_manager.connect_to_server(
+                    server_name=server_config["name"],
+                    command=server_config["command"],
+                    args=server_config.get("args", [])
+                )
+                log.info(f"Connected to MCP server: {server_config['name']}")
+            except Exception as e:
+                log.error(f"Failed to connect to MCP server {server_config['name']}: {e}")
+
+    
+    def handle_mcp_list_tools(self, server_name: Optional[str] = None):
+        """List available MCP tools."""
+        async def get_tools():
+            tools = await self.mcp_client_manager.list_tools(server_name)
+            return [
+                {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "inputSchema": tool.inputSchema,
+                    "server": tool.metadata.get("server") if tool.metadata else server_name
+                }
+                for tool in tools
+            ]
+        
+        # Run async in sync context
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            tools = loop.run_until_complete(get_tools())
+            return jsonify({"tools": tools})
+        finally:
+            loop.close()
+    
+    def handle_mcp_call_tool(self):
+        """Call an MCP tool."""
+        data = request.get_json()
+        server_name = data.get("server")
+        tool_name = data.get("tool")
+        arguments = data.get("arguments", {})
+        
+        if not server_name or not tool_name:
+            return jsonify({"error": "Missing 'server' or 'tool' parameter"}), 400
+        
+        async def call_tool():
+            try:
+                result = await self.mcp_client_manager.call_tool(server_name, tool_name, arguments)
+                
+                # Convert result to JSON-serializable format
+                if hasattr(result, 'content'):
+                    # Handle different content types
+                    if hasattr(result.content, 'text'):
+                        return {"result": result.content.text}
+                    elif hasattr(result.content, 'data'):
+                        return {"result": result.content.data}
+                    else:
+                        return {"result": str(result.content)}
+                else:
+                    return {"result": str(result)}
+                    
+            except Exception as e:
+                return {"error": str(e)}
+        
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            result = loop.run_until_complete(call_tool())
+            if "error" in result:
+                return jsonify(result), 500
+            return jsonify(result)
+        finally:
+            loop.close()
+    
+    def handle_mcp_list_resources(self):
+        """List available MCP resources."""
+        server_name = request.args.get("server")
+        
+        async def get_resources():
+            resources = await self.mcp_client_manager.list_resources(server_name)
+            return [
+                {
+                    "uri": resource.uri,
+                    "name": resource.name,
+                    "description": resource.description,
+                    "mimeType": resource.mimeType,
+                    "server": resource.metadata.get("server") if resource.metadata else server_name
+                }
+                for resource in resources
+            ]
+        
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            resources = loop.run_until_complete(get_resources())
+            return jsonify({"resources": resources})
+        finally:
+            loop.close()
+    
+    def handle_mcp_read_resource(self):
+        """Read an MCP resource."""
+        data = request.get_json()
+        server_name = data.get("server")
+        uri = data.get("uri")
+        
+        if not server_name or not uri:
+            return jsonify({"error": "Missing 'server' or 'uri' parameter"}), 400
+        
+        async def read_resource():
+            try:
+                contents = await self.mcp_client_manager.read_resource(server_name, uri)
+                return {
+                    "contents": [
+                        {"text": content.text} if hasattr(content, 'text') else {"data": str(content)}
+                        for content in contents
+                    ]
+                }
+            except Exception as e:
+                return {"error": str(e)}
+        
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            result = loop.run_until_complete(read_resource())
+            if "error" in result:
+                return jsonify(result), 500
+            return jsonify(result)
+        finally:
+            loop.close()
+    
+    def handle_mcp_server(self):
+        """Handle MCP server requests using HTTP transport."""
+        if not self.vac_mcp_server:
+            return jsonify({"error": "MCP server not enabled"}), 501
+        
+        import json as json_module
+        
+        # Handle streaming for HTTP transport
+        if request.method == 'POST':
+            try:
+                # Get the JSON-RPC request
+                data = request.get_json()
+                log.info(f"MCP server received: {data}")
+                
+                # Create an async handler for the request
+                async def process_request():
+                    # Create mock read/write streams for the server
+                    from io import StringIO
+                    import asyncio
+                    
+                    # Convert request to proper format
+                    request_str = json_module.dumps(data) + '\n'
+                    
+                    # Create read queue with the request
+                    read_queue = asyncio.Queue()
+                    await read_queue.put(request_str.encode())
+                    await read_queue.put(None)  # EOF signal
+                    
+                    # Create write queue for response
+                    write_queue = asyncio.Queue()
+                    
+                    # Create async iterators
+                    async def read_messages():
+                        while True:
+                            msg = await read_queue.get()
+                            if msg is None:
+                                break
+                            yield msg
+                    
+                    responses = []
+                    async def write_messages():
+                        async for msg in write_queue:
+                            if msg is None:
+                                break
+                            responses.append(msg.decode())
+                    
+                    # Run the server with these streams
+                    server = self.vac_mcp_server.get_server()
+                    
+                    # Start write handler
+                    write_task = asyncio.create_task(write_messages())
+                    
+                    try:
+                        # Process the request through the server
+                        await server.run(
+                            read_messages(),
+                            write_queue,
+                            InitializationOptions() if InitializationOptions else None
+                        )
+                    except Exception as e:
+                        log.error(f"Error processing MCP request: {e}")
+                        await write_queue.put(None)
+                        await write_task
+                        raise
+                    
+                    # Signal end and wait for write task
+                    await write_queue.put(None)
+                    await write_task
+                    
+                    # Return collected responses
+                    return responses
+                
+                # Run the async handler
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    responses = loop.run_until_complete(process_request())
+                    
+                    # Parse and return the response
+                    if responses:
+                        # The response should be a single JSON-RPC response
+                        response_data = json_module.loads(responses[0])
+                        return jsonify(response_data)
+                    else:
+                        return jsonify({"error": "No response from MCP server"}), 500
+
+                except Exception as e:
+                    log.error(f"MCP server error: {str(e)}")
+                    return jsonify({
+                        "jsonrpc": "2.0",
+                        "error": {
+                            "code": -32603,
+                            "message": f"Internal error: {str(e)}"
+                        },
+                        "id": data.get("id") if isinstance(data, dict) else None
+                    }), 500
+                finally:
+                    loop.close()
+                        
+            except Exception as e:
+                log.error(f"MCP server error: {str(e)}")
+                return jsonify({
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32603,
+                        "message": f"Internal error: {str(e)}"
+                    },
+                    "id": data.get("id") if isinstance(data, dict) else None
+                }), 500
+                    
+        else:
+            # GET request - return server information
+            return jsonify({
+                "name": "sunholo-vac-server",
+                "version": "1.0.0",
+                "transport": "http",
+                "endpoint": "/mcp",
+                "tools": ["vac_stream", "vac_query"] if self.vac_interpreter else ["vac_stream"]
+            })

sunholo/invoke/async_class.py

@@ -8,12 +8,39 @@ from tenacity import AsyncRetrying, retry_if_exception_type, wait_random_exponen
 log = setup_logging("sunholo_AsyncTaskRunner")
 
 class AsyncTaskRunner:
-    def __init__(self, retry_enabled:bool=False, retry_kwargs:dict=None, timeout:int=120, max_concurrency:int=20):
+    def __init__(self, 
+                 retry_enabled: bool = False, 
+                 retry_kwargs: dict = None, 
+                 timeout: int = 120, 
+                 max_concurrency: int = 20,
+                 heartbeat_extends_timeout: bool = False,
+                 hard_timeout: int = None):
+        """
+        Initialize AsyncTaskRunner with configurable timeout behavior.
+        
+        Args:
+            retry_enabled: Whether to enable retries
+            retry_kwargs: Retry configuration
+            timeout: Base timeout for tasks (seconds)
+            max_concurrency: Maximum concurrent tasks
+            heartbeat_extends_timeout: If True, heartbeats reset the timeout timer
+            hard_timeout: Maximum absolute timeout regardless of heartbeats (seconds).
+                         If None, defaults to timeout * 5 when heartbeat_extends_timeout=True
+        """
         self.tasks = []
         self.retry_enabled = retry_enabled
         self.retry_kwargs = retry_kwargs or {}
         self.timeout = timeout
         self.semaphore = asyncio.Semaphore(max_concurrency)
+        self.heartbeat_extends_timeout = heartbeat_extends_timeout
+        
+        # Set hard timeout
+        if hard_timeout is not None:
+            self.hard_timeout = hard_timeout
+        elif heartbeat_extends_timeout:
+            self.hard_timeout = timeout * 5  # Default to 5x base timeout
+        else:
+            self.hard_timeout = timeout  # Same as regular timeout
 
     def add_task(self, func: Callable[..., Any], *args: Any, **kwargs: Any):
         """
@@ -39,9 +66,11 @@ class AsyncTaskRunner:
         for name, func, args, kwargs in self.tasks:
             log.info(f"Executing task: {name=}, {func=} with args: {args}, kwargs: {kwargs}")
             completion_event = asyncio.Event()
-            task_coro = self._run_with_retries_and_timeout(name, func, args, kwargs, queue, completion_event)            
+            last_heartbeat = {'time': time.time()}  # Shared mutable object for heartbeat tracking
+            
+            task_coro = self._run_with_retries_and_timeout(name, func, args, kwargs, queue, completion_event, last_heartbeat)            
             task = asyncio.create_task(task_coro)
-            heartbeat_coro = self._send_heartbeat(name, completion_event, queue)
+            heartbeat_coro = self._send_heartbeat(name, completion_event, queue, last_heartbeat)
             heartbeat_task = asyncio.create_task(heartbeat_coro)
             task_infos.append({
                 'name': name,
@@ -93,9 +122,12 @@ class AsyncTaskRunner:
                                             args: tuple,
                                             kwargs: dict,
                                             queue: asyncio.Queue, 
-                                            completion_event: asyncio.Event) -> None:
+                                            completion_event: asyncio.Event,
+                                            last_heartbeat: dict) -> None:
         try:
             log.info(f"run_with_retries_and_timeout: {name=}, {func=} with args: {args}, kwargs: {kwargs}")
+            log.info(f"Timeout mode: heartbeat_extends_timeout={self.heartbeat_extends_timeout}, timeout={self.timeout}s, hard_timeout={self.hard_timeout}s")
+            
             if self.retry_enabled:
                 retry_kwargs = {
                     'wait': wait_random_exponential(multiplier=1, max=60),
@@ -106,13 +138,13 @@ class AsyncTaskRunner:
                 async for attempt in AsyncRetrying(**retry_kwargs):
                     with attempt:
                         log.info(f"Starting task '{name}' with retry")
-                        result = await asyncio.wait_for(self._execute_task(func, *args, **kwargs), timeout=self.timeout)
+                        result = await self._execute_task_with_timeout(func, name, last_heartbeat, *args, **kwargs)
                         await queue.put({'type': 'task_complete', 'func_name': name, 'result': result})
                         log.info(f"Sent 'task_complete' message for task '{name}'")
                         return
             else:
                 log.info(f"Starting task '{name}' with no retry")
-                result = await asyncio.wait_for(self._execute_task(func, *args, **kwargs), timeout=self.timeout)
+                result = await self._execute_task_with_timeout(func, name, last_heartbeat, *args, **kwargs)
                 await queue.put({'type': 'task_complete', 'func_name': name, 'result': result})
                 log.info(f"Sent 'task_complete' message for task '{name}'")
         except asyncio.TimeoutError:
@@ -125,6 +157,55 @@ class AsyncTaskRunner:
             log.info(f"Task '{name}' completed.")
             completion_event.set()
 
+    async def _execute_task_with_timeout(self, func: Callable[..., Any], name: str, last_heartbeat: dict, *args: Any, **kwargs: Any) -> Any:
+        """
+        Execute task with either fixed timeout or heartbeat-extendable timeout.
+        """
+        if not self.heartbeat_extends_timeout:
+            # Original behavior - fixed timeout
+            return await asyncio.wait_for(self._execute_task(func, *args, **kwargs), timeout=self.timeout)
+        else:
+            # New behavior - heartbeat extends timeout
+            return await self._execute_task_with_heartbeat_timeout(func, name, last_heartbeat, *args, **kwargs)
+
+    async def _execute_task_with_heartbeat_timeout(self, func: Callable[..., Any], name: str, last_heartbeat: dict, *args: Any, **kwargs: Any) -> Any:
+        """
+        Execute task with heartbeat-extendable timeout and hard timeout limit.
+        """
+        start_time = time.time()
+        task = asyncio.create_task(self._execute_task(func, *args, **kwargs))
+        
+        while not task.done():
+            current_time = time.time()
+            
+            # Check hard timeout first (absolute limit)
+            if current_time - start_time > self.hard_timeout:
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    pass
+                raise asyncio.TimeoutError(f"Hard timeout exceeded ({self.hard_timeout}s)")
+            
+            # Check soft timeout (extends with heartbeats)
+            time_since_heartbeat = current_time - last_heartbeat['time']
+            if time_since_heartbeat > self.timeout:
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    pass
+                raise asyncio.TimeoutError(f"Timeout exceeded - no heartbeat for {self.timeout}s")
+            
+            # Wait a bit before checking again
+            try:
+                await asyncio.wait_for(asyncio.shield(task), timeout=1.0)
+                break  # Task completed
+            except asyncio.TimeoutError:
+                continue  # Check timeouts again
+        
+        return await task
+
     async def _execute_task(self, func: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
         """
         Executes the given task function and returns its result.
@@ -143,14 +224,16 @@ class AsyncTaskRunner:
             else:
                 return await asyncio.to_thread(func, *args, **kwargs)
 
-    async def _send_heartbeat(self, func_name: str, completion_event: asyncio.Event, queue: asyncio.Queue, interval: int = 2):
+    async def _send_heartbeat(self, func_name: str, completion_event: asyncio.Event, queue: asyncio.Queue, last_heartbeat: dict, interval: int = 2):
         """
         Sends periodic heartbeat updates to indicate the task is still in progress.
+        Updates last_heartbeat time if heartbeat_extends_timeout is enabled.
 
         Args:
             func_name (str): The name of the task function.
             completion_event (asyncio.Event): Event to signal when the task is completed.
             queue (asyncio.Queue): The queue to send heartbeat messages to.
+            last_heartbeat (dict): Mutable dict containing the last heartbeat time.
             interval (int): How frequently to send heartbeat messages (in seconds).
         """
         start_time = time.time()
@@ -158,7 +241,14 @@ class AsyncTaskRunner:
         try:
             while not completion_event.is_set():
                 await asyncio.sleep(interval)
-                elapsed_time = int(time.time() - start_time)
+                current_time = time.time()
+                elapsed_time = int(current_time - start_time)
+                
+                # Update last heartbeat time if heartbeat extends timeout
+                if self.heartbeat_extends_timeout:
+                    last_heartbeat['time'] = current_time
+                    log.debug(f"Updated heartbeat time for task '{func_name}' at {current_time}")
+                
                 heartbeat_message = {
                     'type': 'heartbeat',
                     'name': func_name,

sunholo/mcp/__init__.py

@@ -0,0 +1,20 @@
+#   Copyright [2024] [Holosun ApS]
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+"""MCP (Model Context Protocol) integration for Sunholo."""
+
+from .mcp_manager import MCPClientManager
+from .vac_mcp_server import VACMCPServer
+
+__all__ = ['MCPClientManager', 'VACMCPServer']

sunholo/mcp/mcp_manager.py

@@ -0,0 +1,98 @@
+"""
+Proper MCP integration for VACRoutes using the official MCP Python SDK.
+This shows how to integrate MCP servers with your Flask/VACRoutes application.
+"""
+
+from typing import Dict, Any, List, Optional
+
+# Official MCP imports
+from mcp import StdioServerParameters, ClientSession
+from mcp.client.stdio import stdio_client
+from mcp.types import Tool, Resource, TextContent, CallToolResult
+
+
+class MCPClientManager:
+    """Manages MCP client connections to various MCP servers."""
+    
+    def __init__(self):
+        self.sessions: Dict[str, ClientSession] = {}
+        self.server_configs: Dict[str, Dict[str, Any]] = {}
+        
+    async def connect_to_server(self, server_name: str, command: str, args: List[str] = None) -> ClientSession:
+        """Connect to an MCP server via stdio."""
+        if server_name in self.sessions:
+            return self.sessions[server_name]
+        
+        # Create server parameters
+        server_params = StdioServerParameters(
+            command=command,
+            args=args or []
+        )
+        
+        # Connect to the server
+        async with stdio_client(server_params) as (read, write):
+            # Create and initialize client session directly
+            session = ClientSession(read, write)
+            await session.initialize()
+            self.sessions[server_name] = session
+            self.server_configs[server_name] = {
+                "command": command,
+                "args": args
+            }
+            return session
+    
+    async def list_tools(self, server_name: Optional[str] = None) -> List[Tool]:
+        """List available tools from one or all connected servers."""
+        if server_name:
+            session = self.sessions.get(server_name)
+            if session:
+                return await session.list_tools()
+            return []
+        
+        # List from all servers
+        all_tools = []
+        for name, session in self.sessions.items():
+            tools = await session.list_tools()
+            # Add server name to tool metadata
+            for tool in tools:
+                tool.metadata = tool.metadata or {}
+                tool.metadata["server"] = name
+            all_tools.extend(tools)
+        return all_tools
+    
+    async def call_tool(self, server_name: str, tool_name: str, arguments: Dict[str, Any]) -> CallToolResult:
+        """Call a tool on a specific MCP server."""
+        session = self.sessions.get(server_name)
+        if not session:
+            raise ValueError(f"Not connected to server: {server_name}")
+        
+        # Call the tool
+        result = await session.call_tool(tool_name, arguments)
+        return result
+    
+    async def list_resources(self, server_name: Optional[str] = None) -> List[Resource]:
+        """List available resources from servers."""
+        if server_name:
+            session = self.sessions.get(server_name)
+            if session:
+                return await session.list_resources()
+            return []
+        
+        # List from all servers
+        all_resources = []
+        for name, session in self.sessions.items():
+            resources = await session.list_resources()
+            for resource in resources:
+                resource.metadata = resource.metadata or {}
+                resource.metadata["server"] = name
+            all_resources.extend(resources)
+        return all_resources
+    
+    async def read_resource(self, server_name: str, uri: str) -> List[TextContent]:
+        """Read a resource from an MCP server."""
+        session = self.sessions.get(server_name)
+        if not session:
+            raise ValueError(f"Not connected to server: {server_name}")
+        
+        result = await session.read_resource(uri)
+        return result.contents

sunholo/mcp/vac_mcp_server.py

@@ -0,0 +1,259 @@
+#   Copyright [2024] [Holosun ApS]
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+"""
+MCP Server wrapper for VAC functionality.
+This module exposes VAC streaming capabilities as MCP tools.
+"""
+
+from typing import Any, Sequence, Dict, List, Optional, Callable
+import json
+import asyncio
+from functools import partial
+
+try:
+    from mcp.server import Server
+    from mcp.types import Tool, TextContent, ImageContent, EmbeddedResource
+except ImportError:
+    Server = None
+    Tool = None
+    TextContent = None
+
+from ..custom_logging import log
+from ..streaming import start_streaming_chat_async
+
+
+class VACMCPServer:
+    """MCP Server that exposes VAC functionality as tools."""
+    
+    def __init__(self, stream_interpreter: Callable, vac_interpreter: Callable = None):
+        """
+        Initialize the VAC MCP Server.
+        
+        Args:
+            stream_interpreter: The streaming interpreter function
+            vac_interpreter: The static VAC interpreter function (optional)
+        """
+        if Server is None:
+            raise ImportError("MCP server requires `pip install sunholo[anthropic]`")
+        
+        self.stream_interpreter = stream_interpreter
+        self.vac_interpreter = vac_interpreter
+        self.server = Server("sunholo-vac-server")
+        
+        # Set up handlers
+        self._setup_handlers()
+    
+    def _setup_handlers(self):
+        """Set up MCP protocol handlers."""
+        
+        @self.server.list_tools()
+        async def list_tools() -> List[Tool]:
+            """List available VAC tools."""
+            tools = [
+                Tool(
+                    name="vac_stream",
+                    description="Stream responses from a Sunholo VAC (Virtual Agent Computer)",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "vector_name": {
+                                "type": "string",
+                                "description": "Name of the VAC to interact with"
+                            },
+                            "user_input": {
+                                "type": "string", 
+                                "description": "The user's question or input"
+                            },
+                            "chat_history": {
+                                "type": "array",
+                                "description": "Previous conversation history",
+                                "items": {
+                                    "type": "object",
+                                    "properties": {
+                                        "human": {"type": "string"},
+                                        "ai": {"type": "string"}
+                                    }
+                                },
+                                "default": []
+                            },
+                            "stream_wait_time": {
+                                "type": "number",
+                                "description": "Time to wait between stream chunks",
+                                "default": 7
+                            },
+                            "stream_timeout": {
+                                "type": "number",
+                                "description": "Maximum time to wait for response",
+                                "default": 120
+                            }
+                        },
+                        "required": ["vector_name", "user_input"]
+                    }
+                )
+            ]
+            
+            # Add static VAC tool if interpreter is provided
+            if self.vac_interpreter:
+                tools.append(
+                    Tool(
+                        name="vac_query",
+                        description="Query a Sunholo VAC (non-streaming)",
+                        inputSchema={
+                            "type": "object",
+                            "properties": {
+                                "vector_name": {
+                                    "type": "string",
+                                    "description": "Name of the VAC to interact with"
+                                },
+                                "user_input": {
+                                    "type": "string",
+                                    "description": "The user's question or input"
+                                },
+                                "chat_history": {
+                                    "type": "array",
+                                    "description": "Previous conversation history",
+                                    "items": {
+                                        "type": "object",
+                                        "properties": {
+                                            "human": {"type": "string"},
+                                            "ai": {"type": "string"}
+                                        }
+                                    },
+                                    "default": []
+                                }
+                            },
+                            "required": ["vector_name", "user_input"]
+                        }
+                    )
+                )
+            
+            return tools
+        
+        @self.server.call_tool()
+        async def call_tool(
+            name: str,
+            arguments: Any
+        ) -> Sequence[TextContent | ImageContent | EmbeddedResource]:
+            """Handle tool calls for VAC interactions."""
+            
+            if name == "vac_stream":
+                return await self._handle_vac_stream(arguments)
+            elif name == "vac_query" and self.vac_interpreter:
+                return await self._handle_vac_query(arguments)
+            else:
+                raise ValueError(f"Unknown tool: {name}")
+    
+    async def _handle_vac_stream(self, arguments: Dict[str, Any]) -> Sequence[TextContent]:
+        """Handle streaming VAC requests."""
+        vector_name = arguments.get("vector_name")
+        user_input = arguments.get("user_input")
+        chat_history = arguments.get("chat_history", [])
+        stream_wait_time = arguments.get("stream_wait_time", 7)
+        stream_timeout = arguments.get("stream_timeout", 120)
+        
+        if not vector_name or not user_input:
+            raise ValueError("Missing required arguments: vector_name and user_input")
+        
+        log.info(f"MCP streaming request for VAC '{vector_name}': {user_input}")
+        
+        try:
+            # Collect streaming responses
+            full_response = ""
+            
+            async for chunk in start_streaming_chat_async(
+                question=user_input,
+                vector_name=vector_name,
+                qna_func_async=self.stream_interpreter,
+                chat_history=chat_history,
+                wait_time=stream_wait_time,
+                timeout=stream_timeout
+            ):
+                if isinstance(chunk, dict) and 'answer' in chunk:
+                    full_response = chunk['answer']
+                elif isinstance(chunk, str):
+                    full_response += chunk
+            
+            return [
+                TextContent(
+                    type="text",
+                    text=full_response or "No response generated"
+                )
+            ]
+            
+        except Exception as e:
+            log.error(f"Error in MCP VAC stream: {str(e)}")
+            return [
+                TextContent(
+                    type="text",
+                    text=f"Error: {str(e)}"
+                )
+            ]
+    
+    async def _handle_vac_query(self, arguments: Dict[str, Any]) -> Sequence[TextContent]:
+        """Handle non-streaming VAC requests."""
+        vector_name = arguments.get("vector_name")
+        user_input = arguments.get("user_input")
+        chat_history = arguments.get("chat_history", [])
+        
+        if not vector_name or not user_input:
+            raise ValueError("Missing required arguments: vector_name and user_input")
+        
+        log.info(f"MCP query request for VAC '{vector_name}': {user_input}")
+        
+        try:
+            # Run in executor if not async
+            if asyncio.iscoroutinefunction(self.vac_interpreter):
+                result = await self.vac_interpreter(
+                    question=user_input,
+                    vector_name=vector_name,
+                    chat_history=chat_history
+                )
+            else:
+                loop = asyncio.get_event_loop()
+                result = await loop.run_in_executor(
+                    None,
+                    partial(
+                        self.vac_interpreter,
+                        question=user_input,
+                        vector_name=vector_name,
+                        chat_history=chat_history
+                    )
+                )
+            
+            # Extract answer from result
+            if isinstance(result, dict):
+                answer = result.get("answer", str(result))
+            else:
+                answer = str(result)
+            
+            return [
+                TextContent(
+                    type="text",
+                    text=answer
+                )
+            ]
+            
+        except Exception as e:
+            log.error(f"Error in MCP VAC query: {str(e)}")
+            return [
+                TextContent(
+                    type="text",
+                    text=f"Error: {str(e)}"
+                )
+            ]
+    
+    def get_server(self) -> Server:
+        """Get the underlying MCP server instance."""
+        return self.server

{sunholo-0.141.1.dist-info → sunholo-0.143.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.141.1
+Version: 0.143.1
 Summary: AI DevOps - a package to help deploy GenAI to the Cloud.
 Author-email: Holosun ApS <multivac@sunholo.com>
 License: Apache License, Version 2.0
@@ -19,10 +19,11 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: aiohttp
+Requires-Dist: flask>=3.1.0
 Requires-Dist: google-auth
-Requires-Dist: ollama>=0.4.7
-Requires-Dist: pillow>=11.0.0
+Requires-Dist: mcp>=1.1.1
 Requires-Dist: pydantic
+Requires-Dist: pytest-asyncio>=1.0.0
 Requires-Dist: requests
 Requires-Dist: ruamel.yaml
 Requires-Dist: tenacity
@@ -69,7 +70,7 @@ Requires-Dist: langchain-anthropic>=0.1.23; extra == "all"
 Requires-Dist: langchain-google-vertexai; extra == "all"
 Requires-Dist: langchain-unstructured; extra == "all"
 Requires-Dist: langfuse; extra == "all"
-Requires-Dist: mcp; extra == "all"
+Requires-Dist: mcp>=1.1.1; extra == "all"
 Requires-Dist: numpy; extra == "all"
 Requires-Dist: opencv-python; extra == "all"
 Requires-Dist: pg8000; extra == "all"
@@ -155,7 +156,7 @@ Requires-Dist: langchain-openai>=0.3.2; extra == "openai"
 Requires-Dist: tiktoken; extra == "openai"
 Provides-Extra: anthropic
 Requires-Dist: langchain-anthropic>=0.1.23; extra == "anthropic"
-Requires-Dist: mcp; extra == "anthropic"
+Requires-Dist: mcp>=1.1.1; extra == "anthropic"
 Provides-Extra: tools
 Requires-Dist: openapi-spec-validator; extra == "tools"
 Requires-Dist: playwright; extra == "tools"

{sunholo-0.141.1.dist-info → sunholo-0.143.1.dist-info}/RECORD

@@ -14,7 +14,7 @@ sunholo/agents/fastapi/base.py,sha256=W-cyF8ZDUH40rc-c-Apw3-_8IIi2e4Y9qRtnoVnsc1
 sunholo/agents/fastapi/qna_routes.py,sha256=lKHkXPmwltu9EH3RMwmD153-J6pE7kWQ4BhBlV3to-s,3864
 sunholo/agents/flask/__init__.py,sha256=dEoByI3gDNUOjpX1uVKP7uPjhfFHJubbiaAv3xLopnk,63
 sunholo/agents/flask/base.py,sha256=vnpxFEOnCmt9humqj-jYPLfJcdwzsop9NorgkJ-tSaU,1756
-sunholo/agents/flask/vac_routes.py,sha256=TEM0u2vkZC0BSKJABxQVPm4QiUsEFoPOwJZIOxzi1Sk,32621
+sunholo/agents/flask/vac_routes.py,sha256=P_swGAAEee2Z9BdOTQEFza9aI78ezCVtF1MNNi67pug,44599
 sunholo/archive/__init__.py,sha256=qNHWm5rGPVOlxZBZCpA1wTYPbalizRT7f8X4rs2t290,31
 sunholo/archive/archive.py,sha256=PxVfDtO2_2ZEEbnhXSCbXLdeoHoQVImo4y3Jr2XkCFY,1204
 sunholo/auth/__init__.py,sha256=TeP-OY0XGxYV_8AQcVGoh35bvyWhNUcMRfhuD5l44Sk,91
@@ -96,7 +96,7 @@ sunholo/genai/init.py,sha256=yG8E67TduFCTQPELo83OJuWfjwTnGZsyACospahyEaY,687
 sunholo/genai/process_funcs_cls.py,sha256=D6eNrc3vtTZzwdkacZNOSfit499N_o0C5AHspyUJiYE,33690
 sunholo/genai/safety.py,sha256=mkFDO_BeEgiKjQd9o2I4UxB6XI7a9U-oOFjZ8LGRUC4,1238
 sunholo/invoke/__init__.py,sha256=o1RhwBGOtVK0MIdD55fAIMCkJsxTksi8GD5uoqVKI-8,184
-sunholo/invoke/async_class.py,sha256=OmRHaRf_yXNDWftWPpziytXh1TAhMumxnNhN_PGpQFs,8230
+sunholo/invoke/async_class.py,sha256=ZMzxKQtelbYibu9Fac7P9OU3GorH8KxawZxSMv5EO9A,12514
 sunholo/invoke/direct_vac_func.py,sha256=dACx3Zh7uZnuWLIFYiyLoyXUhh5-eUpd2RatDUd9ov8,9753
 sunholo/invoke/invoke_vac_utils.py,sha256=sJc1edHTHMzMGXjji1N67c3iUaP7BmAL5nj82Qof63M,2053
 sunholo/langfuse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -110,8 +110,10 @@ sunholo/llamaindex/llamaindex_class.py,sha256=PnpPoc7LpP7xvKIXYu-UvI4ehj67pGhE1E
 sunholo/llamaindex/user_history.py,sha256=ZtkecWuF9ORduyGB8kF8gP66bm9DdvCI-ZiK6Kt-cSE,2265
 sunholo/lookup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sunholo/lookup/model_lookup.yaml,sha256=O7o-jP53MLA06C8pI-ILwERShO-xf6z_258wtpZBv6A,739
-sunholo/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sunholo/mcp/__init__.py,sha256=GmKB8Z0ecXUzpuzYEOXSI0aaZP7LZJc7yTCMEFdAmi4,791
 sunholo/mcp/cli.py,sha256=d24nnVzhZYz4AWgTqmN-qjKG4rPbf8RhdmEOHZkBHy8,10570
+sunholo/mcp/mcp_manager.py,sha256=ooa_2JSNaKIuK9azEV0OaPVf5Mp_tL_DHaYEyFCmgKY,3752
+sunholo/mcp/vac_mcp_server.py,sha256=fRcerTqp_pTK8AVITpGPhrez_IaDuUDr4WnVUHPv8GM,10114
 sunholo/ollama/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sunholo/ollama/ollama_images.py,sha256=H2cpcNu88R4TwyfL_nnqkQhdvBQ2FPCAy4Ok__0yQmo,2351
 sunholo/pubsub/__init__.py,sha256=DfTEk4zmCfqn6gFxRrqDO0pOrvXTDqH-medpgYO4PGw,117
@@ -169,9 +171,9 @@ sunholo/vertex/init.py,sha256=1OQwcPBKZYBTDPdyU7IM4X4OmiXLdsNV30C-fee2scQ,2875
 sunholo/vertex/memory_tools.py,sha256=tBZxqVZ4InTmdBvLlOYwoSEWu4-kGquc-gxDwZCC4FA,7667
 sunholo/vertex/safety.py,sha256=S9PgQT1O_BQAkcqauWncRJaydiP8Q_Jzmu9gxYfy1VA,2482
 sunholo/vertex/type_dict_to_json.py,sha256=uTzL4o9tJRao4u-gJOFcACgWGkBOtqACmb6ihvCErL8,4694
-sunholo-0.141.1.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.141.1.dist-info/METADATA,sha256=Ett7hxu4MPWMTgGQyVNADbvuuPOWvXIVUl2aRLXgNn8,18292
-sunholo-0.141.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sunholo-0.141.1.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.141.1.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.141.1.dist-info/RECORD,,
+sunholo-0.143.1.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.143.1.dist-info/METADATA,sha256=bvNatmW9CaH2Fyn2AN8np1IeiLF0MNciSg7gjihkYvI,18338
+sunholo-0.143.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sunholo-0.143.1.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.143.1.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.143.1.dist-info/RECORD,,