auto-coder 0.1.215__py3-none-any.whl → 0.1.218__py3-none-any.whl

autocoder/common/mcp_server.py

@@ -6,17 +6,100 @@ from dataclasses import dataclass
 import byzerllm
 from autocoder.common.mcp_hub import McpHub
 from autocoder.common.mcp_tools import McpExecutor
+from autocoder.common.mcp_hub import MCP_BUILD_IN_SERVERS
+import json
+import os
+import time
+from pydantic import BaseModel
+import sys
+from loguru import logger
 
-@dataclass 
+@dataclass
 class McpRequest:
     query: str
     model: Optional[str] = None
-    
+
+
+@dataclass
+class McpInstallRequest:
+    server_name_or_config: Optional[str] = None
+
+
+@dataclass
+class McpRemoveRequest:
+    server_name: str
+
+
+@dataclass
+class McpListRequest:
+    """Request to list all builtin MCP servers"""
+    pass
+
+
+@dataclass
+class McpListRunningRequest:
+    """Request to list all running MCP servers"""
+    pass
+
 @dataclass
 class McpResponse:
     result: str
     error: Optional[str] = None
 
+
+@dataclass
+class McpRefreshRequest:
+    """Request to refresh MCP server connections"""
+    name: Optional[str] = None
+
+
+@dataclass
+class McpExternalServer(BaseModel):
+    result: str
+    error: Optional[str] = None
+
+
+class McpExternalServer(BaseModel):
+    """Represents an external MCP server configuration"""
+    name: str
+    description: str
+    vendor: str
+    sourceUrl: str
+    homepage: str
+    license: str
+    runtime: str
+
+
+def get_mcp_external_servers() -> List[McpExternalServer]:
+    """Get external MCP servers list from GitHub"""
+    cache_dir = os.path.join(".auto-coder", "tmp")
+    os.makedirs(cache_dir, exist_ok=True)
+    cache_file = os.path.join(cache_dir, "mcp_external_servers.json")
+
+    # Check cache first
+    if os.path.exists(cache_file):
+        cache_time = os.path.getmtime(cache_file)
+        if time.time() - cache_time < 3600:  # 1 hour cache
+            with open(cache_file, "r") as f:
+                raw_data = json.load(f)
+                return [McpExternalServer(**item) for item in raw_data]
+
+    # Fetch from GitHub
+    url = "https://raw.githubusercontent.com/michaellatman/mcp-get/refs/heads/main/packages/package-list.json"
+    try:
+        import requests
+        response = requests.get(url)
+        if response.status_code == 200:
+            raw_data = response.json()
+            with open(cache_file, "w") as f:
+                json.dump(raw_data, f)
+            return [McpExternalServer(**item) for item in raw_data]
+        return []
+    except Exception as e:
+        logger.error(f"Failed to fetch external MCP servers: {e}")
+        return []
+
+
 class McpServer:
     def __init__(self):
         self._request_queue = AsyncQueue()
@@ -24,57 +107,205 @@ class McpServer:
         self._running = False
         self._task = None
         self._loop = None
-        
+
     def start(self):
         if self._running:
             return
-            
+
         self._running = True
         self._loop = asyncio.new_event_loop()
         threading.Thread(target=self._run_event_loop, daemon=True).start()
-        
+
     def stop(self):
         if self._running:
-            self._running = False            
+            self._running = False
             if self._loop:
                 self._loop.stop()
                 self._loop.close()
-                
+
     def _run_event_loop(self):
         asyncio.set_event_loop(self._loop)
         self._task = self._loop.create_task(self._process_request())
         self._loop.run_forever()
-                
+
+    async def _install_server(self, request: McpInstallRequest, hub: McpHub) -> McpResponse:
+        """Install an MCP server with module dependency check"""
+        name = ""
+        config = {}
+        try:
+            server_name_or_config = request.server_name_or_config
+            try:
+                raw_config = json.loads(server_name_or_config)
+                # 用户给了一个完整的配置
+                if "mcpServers" in raw_config:
+                    raw_config = raw_config["mcpServers"]
+
+                # 取第一个server 配置
+                config = list(raw_config.values())[0]
+                name = list(raw_config.keys())[0]
+            except json.JSONDecodeError:
+                name = server_name_or_config.strip()
+                if name not in MCP_BUILD_IN_SERVERS:
+                    # 查找外部server
+                    external_servers = get_mcp_external_servers()
+                    for s in external_servers:
+                        if s.name == name:
+                            if s.runtime == "python":
+                                # Check if module exists
+                                try:
+                                    import importlib
+                                    importlib.import_module(
+                                        name.replace("-", "_"))
+                                except ImportError:
+                                    # Install missing module
+                                    import subprocess
+                                    try:
+                                        subprocess.run(
+                                            [sys.executable, "-m", "pip", "install", name], check=True)
+                                    except subprocess.CalledProcessError:
+                                        print(
+                                            f"\n\033[93mFailed to automatically install {name}. Please manually install it using:\n")
+                                        print(f"    pip install {name}\n")
+                                        print(
+                                            f"We have already updated the server configuration in ~/.autocoder/mcp/settings.json.\n")
+                                        print(
+                                            f"After installation, you can restart the auto-coder.chat using the server.\033[0m\n")
+
+                                config = {
+                                    "command": "python",
+                                    "args": [
+                                        "-m", name.replace("-", "_")
+                                    ],
+                                }
+                            elif s.runtime == "node":
+                                # Check if package exists
+                                try:
+                                    subprocess.run(
+                                        ["npx", name, "--version"], check=True)
+                                except:
+                                    # Install missing package
+                                    try:
+                                        subprocess.run(
+                                            ["npm", "install", "-y", "-g", name], check=True)
+                                    except subprocess.CalledProcessError:
+                                        print(
+                                            f"\n\033[93mFailed to automatically install {name}. Please manually install it using:\n")
+                                        print(f"    npm install -g {name}\n")
+                                        print(
+                                            f"We have already updated the server configuration in ~/.autocoder/mcp/settings.json.\n")
+                                        print(
+                                            f"After installation, you can restart the auto-coder.chat using the server.\033[0m\n")
+
+                                config = {
+                                    "command": "npx",
+                                    "args": [
+                                        "-y",
+                                        name
+                                    ]
+                                }
+                            break
+                else:
+                    config = MCP_BUILD_IN_SERVERS[name]
+            if not name:
+                raise ValueError(
+                    "MCP server name is not available in MCP_BUILD_IN_SERVERS or external servers")
+
+            logger.info(f"Installing MCP server: {name} with config: {config}")
+            if not config:
+                raise ValueError(f"MCP server {name} config is not available")
+
+            await hub.add_server_config(name, config)
+            return McpResponse(result=f"Successfully installed MCP server: {request.server_name_or_config}")
+        except Exception as e:
+            return McpResponse(result="", error=f"Failed to install MCP server: {str(e)}")
+
     async def _process_request(self):
         hub = McpHub()
         await hub.initialize()
-        
+
         while self._running:
             try:
                 request = await self._request_queue.get()
                 if request is None:
                     break
-                    
-                llm = byzerllm.ByzerLLM.from_default_model(model=request.model)
-                mcp_executor = McpExecutor(hub, llm)
-                conversations = [{"role": "user", "content": request.query}]
-                _, results = await mcp_executor.run(conversations)
-                results_str = "\n\n".join(mcp_executor.format_mcp_result(result) for result in results)
-                await self._response_queue.put(McpResponse(result=results_str))
+
+                if isinstance(request, McpInstallRequest):
+                    response = await self._install_server(request, hub)
+                    await self._response_queue.put(response)
+
+                elif isinstance(request, McpRemoveRequest):
+                    try:
+                        await hub.remove_server_config(request.server_name)
+                        await self._response_queue.put(McpResponse(result=f"Successfully removed MCP server: {request.server_name}"))
+                    except Exception as e:
+                        await self._response_queue.put(McpResponse(result="", error=f"Failed to remove MCP server: {str(e)}"))
+
+                elif isinstance(request, McpListRequest):
+                    try:
+                        # Get built-in servers
+                        builtin_servers = [
+                            f"- Built-in: {name}" for name in MCP_BUILD_IN_SERVERS.keys()]
+
+                        # Get external servers
+                        external_servers = get_mcp_external_servers()
+                        external_list = [
+                            f"- External: {s.name} ({s.description})" for s in external_servers]
+
+                        # Combine results
+                        all_servers = builtin_servers + external_list
+                        result = "Available MCP servers:\n" + \
+                            "\n".join(all_servers)
+
+                        await self._response_queue.put(McpResponse(result=result))
+                    except Exception as e:
+                        await self._response_queue.put(McpResponse(result="", error=f"Failed to list servers: {str(e)}"))
+
+                elif isinstance(request, McpListRunningRequest):
+                    try:
+                        running_servers = "\n".join(
+                            [f"- {server.name}" for server in hub.get_servers()])
+                        await self._response_queue.put(McpResponse(result=running_servers))
+                    except Exception as e:
+                        await self._response_queue.put(McpResponse(result="", error=f"Failed to list running servers: {str(e)}"))
+
+                elif isinstance(request, McpRefreshRequest):
+                    try:
+                        if request.name:
+                            await hub.refresh_server_connection(request.name)
+                        else:
+                            await hub.initialize()
+                        await self._response_queue.put(McpResponse(result="Successfully refreshed MCP server connections"))
+                    except Exception as e:
+                        await self._response_queue.put(McpResponse(result="", error=f"Failed to refresh MCP servers: {str(e)}"))
+
+                else:
+                    llm = byzerllm.ByzerLLM.from_default_model(
+                        model=request.model)
+                    mcp_executor = McpExecutor(hub, llm)
+                    conversations = [
+                        {"role": "user", "content": request.query}]
+                    _, results = await mcp_executor.run(conversations)
+                    if not results:
+                        await self._response_queue.put(McpResponse(result="[No Result]", error="No results"))
+                    results_str = "\n\n".join(
+                        mcp_executor.format_mcp_result(result) for result in results)
+                    await self._response_queue.put(McpResponse(result=results_str))
             except Exception as e:
                 await self._response_queue.put(McpResponse(result="", error=str(e)))
-        
+
     def send_request(self, request: McpRequest) -> McpResponse:
         async def _send():
             await self._request_queue.put(request)
             return await self._response_queue.get()
-            
+
         future = asyncio.run_coroutine_threadsafe(_send(), self._loop)
         return future.result()
 
+
 # Global MCP server instance
 _mcp_server = None
 
+
 def get_mcp_server():
     global _mcp_server
     if _mcp_server is None:

autocoder/common/mcp_servers/mcp_server_perplexity.py

@@ -0,0 +1,135 @@
+from os import getenv
+from textwrap import dedent
+
+import httpx
+import mcp.server.stdio
+import mcp.types as types
+from mcp.server import NotificationOptions, Server
+from mcp.server.models import InitializationOptions
+import json
+
+PERPLEXITY_API_KEY = getenv("PERPLEXITY_API_KEY")
+PERPLEXITY_API_BASE_URL = "https://api.perplexity.ai"
+
+
+server = Server("mcp-server-perplexity")
+
+
+@server.list_tools()
+async def handle_list_tools() -> list[types.Tool]:
+    return [
+        types.Tool(
+            name="ask_perplexity",
+            description=dedent(
+                """
+                Perplexity equips agents with a specialized tool for efficiently
+                gathering source-backed information from the internet, ideal for
+                scenarios requiring research, fact-checking, or contextual data to
+                inform decisions and responses.
+                Each response includes citations, which provide transparent references
+                to the sources used for the generated answer, and choices, which
+                contain the model's suggested responses, enabling users to access
+                reliable information and diverse perspectives.
+                This function may encounter timeout errors due to long processing times,
+                but retrying the operation can lead to successful completion.
+                [Response structure]
+                - id: An ID generated uniquely for each response.
+                - model: The model used to generate the response.
+                - object: The object type, which always equals `chat.completion`.
+                - created: The Unix timestamp (in seconds) of when the completion was
+                  created.
+                - citations[]: Citations for the generated answer.
+                - choices[]: The list of completion choices the model generated for the
+                  input prompt.
+                - usage: Usage statistics for the completion request.
+                """
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "model": {
+                        "type": "string",
+                        "description": "The name of the model that will complete your prompt.",
+                        "enum": [
+                            "llama-3.1-sonar-small-128k-online",
+                            # Commenting out larger models,which have higher risks of timing out,
+                            # until Claude Desktop can handle long-running tasks effectively.
+                            # "llama-3.1-sonar-large-128k-online",
+                            # "llama-3.1-sonar-huge-128k-online",
+                        ],
+                    },
+                    "messages": {
+                        "type": "array",
+                        "description": "A list of messages comprising the conversation so far.",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "content": {
+                                    "type": "string",
+                                    "description": "The contents of the message in this turn of conversation.",
+                                },
+                                "role": {
+                                    "type": "string",
+                                    "description": "The role of the speaker in this turn of conversation. After the (optional) system message, user and assistant roles should alternate with user then assistant, ending in user.",
+                                    "enum": ["system", "user", "assistant"],
+                                },
+                            },
+                            "required": ["content", "role"],
+                        },
+                    },
+                },
+                "required": ["model", "messages"],
+            },
+        )
+    ]
+
+
+@server.call_tool()
+async def handle_call_tool(
+    name: str, arguments: dict
+) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+    if name != "ask_perplexity":
+        raise ValueError(f"Unknown tool: {name}")
+
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{PERPLEXITY_API_BASE_URL}/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {PERPLEXITY_API_KEY}",
+                    "Content-Type": "application/json",
+                },
+                json=arguments,
+                timeout=None,
+            )
+            response.raise_for_status()
+    except httpx.HTTPError as e:
+        raise RuntimeError(f"API error: {str(e)}")
+
+    result = json.loads(response.text)
+    c = result["choices"][0]["message"]["content"]
+    return [types.TextContent(
+            type="text",
+            text= c,
+            )]
+
+
+async def main():
+    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="mcp-server-perplexity",
+                server_version="0.1.2",
+                capabilities=server.get_capabilities(
+                    notification_options=NotificationOptions(
+                        tools_changed=True),
+                    experimental_capabilities={},
+                ),
+            ),
+        )
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())