casual-mcp 0.1.0__py3-none-any.whl

casual_mcp/__init__.py

@@ -0,0 +1,13 @@
+from . import models
+from .mcp_tool_chat import McpToolChat
+from .multi_server_mcp_client import MultiServerMCPClient
+from .providers.provider_factory import ProviderFactory
+from .utils import load_config
+
+__all__ = [
+    "McpToolChat",
+    "MultiServerMCPClient",
+    "ProviderFactory",
+    "load_config",
+    "models",
+]

casual_mcp/cli.py

@@ -0,0 +1,68 @@
+import typer
+import uvicorn
+from rich.console import Console
+from rich.table import Table
+
+from casual_mcp.utils import load_config
+
+app = typer.Typer()
+console = Console()
+
+@app.command()
+def serve(host: str = "0.0.0.0", port: int = 8000, reload: bool = True):
+    """
+    Start the Casual MCP API server.
+    """
+    uvicorn.run(
+        "casual_mcp.main:app",
+        host=host,
+        port=port,
+        reload=reload,
+        app_dir="src"
+    )
+
+@app.command()
+def servers():
+    """
+    Return a table of all configured servers
+    """
+    config = load_config('config.json')
+    table = Table("Name", "Type", "Path / Package / Url", "Env")
+
+    for name, server in config.servers.items():
+        path = ''
+        match server.type:
+            case 'python':
+                path = server.path
+            case 'node':
+                path = server.path
+            case 'http':
+                path = server.url
+            case 'uvx':
+                path = server.package
+        env = ''
+
+        table.add_row(name, server.type, path, env)
+
+    console.print(table)
+
+@app.command()
+def models():
+    """
+    Return a table of all configured models
+    """
+    config = load_config('config.json')
+    table = Table("Name", "Provider", "Model", "Endpoint")
+
+    for name, model in config.models.items():
+        endpoint = ''
+        if model.provider == 'openai':
+            endpoint = model.endpoint or ''
+
+        table.add_row(name, model.provider, model.model, str(endpoint))
+
+    console.print(table)
+
+
+if __name__ == "__main__":
+    app()

casual_mcp/logging.py

@@ -0,0 +1,30 @@
+import logging
+from typing import Literal
+
+from rich.console import Console
+from rich.logging import RichHandler
+
+
+def get_logger(name: str) -> logging.Logger:
+    return logging.getLogger(f"casual_mcp.{name}")
+
+
+def configure_logging(
+    level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | int = "INFO",
+    logger: logging.Logger | None = None,
+) -> None:
+    if logger is None:
+        logger = logging.getLogger("casual_mcp")
+
+    handler = RichHandler(console=Console(stderr=True), rich_tracebacks=True)
+    formatter = logging.Formatter("%(name)s: %(message)s")
+    handler.setFormatter(formatter)
+
+    logger.setLevel(level)
+
+    # Remove any existing handlers to avoid duplicates on reconfiguration
+    for hdlr in logger.handlers[:]:
+        logger.removeHandler(hdlr)
+
+    logger.addHandler(handler)
+    logger.info("Logging Configured")

casual_mcp/main.py

@@ -0,0 +1,118 @@
+import os
+import sys
+from pathlib import Path
+
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
+
+from casual_mcp import McpToolChat, MultiServerMCPClient
+from casual_mcp.logging import configure_logging, get_logger
+from casual_mcp.models.messages import CasualMcpMessage
+from casual_mcp.providers.provider_factory import ProviderFactory
+from casual_mcp.utils import load_config, render_system_prompt
+
+load_dotenv()
+config = load_config("config.json")
+mcp_client = MultiServerMCPClient(namespace_tools=config.namespace_tools)
+provider_factory = ProviderFactory()
+
+app = FastAPI()
+
+default_system_prompt = """You are a helpful assistant.
+
+You have access to up-to-date information through the tools, but you must never mention that tools were used.
+
+Respond naturally and confidently, as if you already know all the facts.
+
+**Never mention your knowledge cutoff, training data, or when you were last updated.**
+
+You must not speculate or guess about dates — if a date is given to you by a tool, assume it is correct and respond accordingly without disclaimers.
+
+Always present information as current and factual.
+"""
+
+class GenerateRequest(BaseModel):
+    session_id: str | None = Field(
+        default=None, title="Session to use"
+    )
+    model: str = Field(
+        title="Model to user"
+    )
+    system_prompt: str | None = Field(
+        default=None, title="System Prompt to use"
+    )
+    user_prompt: str = Field(
+        title="User Prompt"
+    )
+    messages: list[CasualMcpMessage] | None = Field(
+        default=None, title="Previous messages to supply to the LLM"
+    )
+
+sys.path.append(str(Path(__file__).parent.resolve()))
+
+# Configure logging
+configure_logging(os.getenv("LOG_LEVEL", 'INFO'))
+logger = get_logger("main")
+
+async def perform_chat(
+    model,
+    user,
+    system: str | None = None,
+    messages: list[CasualMcpMessage] = None,
+    session_id: str | None = None
+) -> list[CasualMcpMessage]:
+    # Get Provider from Model Config
+    model_config = config.models[model]
+    provider = provider_factory.get_provider(model, model_config)
+
+    if not system:
+        if (model_config.template):
+            system = render_system_prompt(
+                f"{model_config.template}.j2",
+                await mcp_client.list_tools()
+            )
+        else:
+            system = default_system_prompt
+
+    chat = McpToolChat(mcp_client, provider, system)
+    return await chat.chat(
+        prompt=user,
+        messages=messages,
+        session_id=session_id
+    )
+
+
+@app.post("/chat")
+async def chat(req: GenerateRequest):
+    if len(mcp_client.tools) == 0:
+        await mcp_client.load_config(config.servers)
+        provider_factory.set_tools(await mcp_client.list_tools())
+
+    messages = await perform_chat(
+        req.model,
+        system=req.system_prompt,
+        user=req.user_prompt,
+        messages=req.messages,
+        session_id=req.session_id
+    )
+
+    return {
+        "messages": messages,
+        "response": messages[len(messages) - 1].content
+    }
+
+
+# This endpoint will either go away or be used for something else, don't use it
+@app.post("/generate")
+async def generate_response(req: GenerateRequest):
+    return await chat(req)
+
+
+@app.get("/chat/session/{session_id}")
+async def get_chat_session(session_id):
+    session = McpToolChat.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    return session

casual_mcp/mcp_tool_chat.py

@@ -0,0 +1,90 @@
+
+from casual_mcp.logging import get_logger
+from casual_mcp.models.messages import CasualMcpMessage, SystemMessage, UserMessage
+from casual_mcp.multi_server_mcp_client import MultiServerMCPClient
+from casual_mcp.providers.provider_factory import LLMProvider
+
+logger = get_logger("mcp_tool_chat")
+sessions: dict[str, list[CasualMcpMessage]] = {}
+
+
+class McpToolChat:
+    def __init__(self, tool_client: MultiServerMCPClient, provider: LLMProvider, system: str):
+        self.provider = provider
+        self.tool_client = tool_client
+        self.system = system
+
+    @staticmethod
+    def get_session(session_id) -> list[CasualMcpMessage] | None:
+        global sessions
+        return sessions.get(session_id)
+
+    async def chat(
+        self,
+        prompt: str | None = None,
+        messages: list[CasualMcpMessage] = None,
+        session_id: str | None = None
+    ) -> list[CasualMcpMessage]:
+        global sessions
+
+        # todo: check that we have a prompt or that there is a user message in messages
+
+        # If we have a session ID then create if new and fetch it
+        if session_id:
+            if not sessions.get(session_id):
+                logger.info(f"Starting new session {session_id}")
+                sessions[session_id] = []
+            else:
+                logger.info(
+                    f"Retrieving session {session_id} of length {len(sessions[session_id])}"
+                )
+            messages = sessions[session_id].copy()
+
+        logger.info("Start Chat")
+        tools = await self.tool_client.list_tools()
+
+        if messages is None or len(messages) == 0:
+            message_history = []
+            messages = [SystemMessage(content=self.system)]
+        else:
+            message_history = messages.copy()
+
+        if prompt:
+            messages.append(UserMessage(content=prompt))
+
+        response: str | None = None
+        while True:
+            logger.info("Calling the LLM")
+            ai_message = await self.provider.generate(messages, tools)
+            response = ai_message.content
+
+            # Add the assistant's message
+            messages.append(ai_message)
+
+            if not ai_message.tool_calls:
+                break
+
+            if ai_message.tool_calls and len(ai_message.tool_calls) > 0:
+                logger.info(f"Executing {len(ai_message.tool_calls)} tool calls")
+                result_count = 0
+                for tool_call in ai_message.tool_calls:
+                    try:
+                        result = await self.tool_client.execute(tool_call)
+                    except Exception as e:
+                        logger.error(e)
+                        return messages
+                    if result:
+                        messages.append(result)
+                        result_count = result_count + 1
+
+                logger.info(f"Added {result_count} tool results")
+
+        logger.debug(f"""Final Response:
+{response} """)
+
+        new_messages = [item for item in messages if item not in message_history]
+        if session_id:
+            sessions[session_id].extend(new_messages)
+
+        return new_messages
+

casual_mcp/models/__init__.py

@@ -0,0 +1,33 @@
+from .mcp_server_config import (
+    HttpMcpServerConfig,
+    McpServerConfig,
+    NodeMcpServerConfig,
+    PythonMcpServerConfig,
+    UvxMcpServerConfig,
+)
+from .messages import (
+    AssistantMessage,
+    CasualMcpMessage,
+    SystemMessage,
+    ToolResultMessage,
+    UserMessage,
+)
+from .model_config import (
+    ModelConfig,
+    OpenAIModelConfig,
+)
+
+__all__ = [
+    "UserMessage",
+    "AssistantMessage",
+    "ToolResultMessage",
+    "SystemMessage",
+    "CasualMcpMessage",
+    "ModelConfig",
+    "OpenAIModelConfig",
+    "McpServerConfig",
+    "PythonMcpServerConfig",
+    "UvxMcpServerConfig",
+    "NodeMcpServerConfig",
+    "HttpMcpServerConfig",
+]

casual_mcp/models/config.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+from casual_mcp.models.mcp_server_config import McpServerConfig
+from casual_mcp.models.model_config import ModelConfig
+
+
+class Config(BaseModel):
+    namespace_tools: bool | None = False
+    models: dict[str, ModelConfig]
+    servers: dict[str, McpServerConfig]

casual_mcp/models/generation_error.py

@@ -0,0 +1,10 @@
+class GenerationError(Exception):
+    """Exception raised for custom error scenarios.
+
+    Attributes:
+        message -- explanation of the error
+    """
+
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)

casual_mcp/models/mcp_server_config.py

@@ -0,0 +1,39 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class BaseMcpServerConfig(BaseModel):
+    type: Literal["python", "node", "http", "uvx"]
+    system_prompt: str | None | None = None
+
+
+class PythonMcpServerConfig(BaseMcpServerConfig):
+    type: Literal["python"] = "python"
+    path: str
+    env: dict[str, str] | None | None = None
+
+
+class UvxMcpServerConfig(BaseMcpServerConfig):
+    type: Literal["uvx"] = "uvx"
+    package: str
+    env: dict[str, str] | None | None = None
+
+
+class NodeMcpServerConfig(BaseMcpServerConfig):
+    type: Literal["node"] = "node"
+    path: str
+    env: dict[str, str] | None | None = None
+
+
+class HttpMcpServerConfig(BaseMcpServerConfig):
+    type: Literal["http"] = "http"
+    url: str
+
+
+McpServerConfig = (
+    PythonMcpServerConfig
+    | NodeMcpServerConfig
+    | HttpMcpServerConfig
+    | UvxMcpServerConfig
+)

casual_mcp/models/messages.py

@@ -0,0 +1,31 @@
+from typing import Literal, TypeAlias
+
+from pydantic import BaseModel
+
+from casual_mcp.models.tool_call import AssistantToolCall
+
+
+class AssistantMessage(BaseModel):
+    role: Literal["assistant"] = "assistant"
+    content: str | None
+    tool_calls: list[AssistantToolCall] | None
+
+
+class SystemMessage(BaseModel):
+    role: Literal["system"] = "system"
+    content: str
+
+
+class ToolResultMessage(BaseModel):
+    role: Literal["tool"] = "tool"
+    name: str
+    tool_call_id: str
+    content: str
+
+
+class UserMessage(BaseModel):
+    role: Literal["user"] = "user"
+    content: str | None
+
+
+CasualMcpMessage: TypeAlias = AssistantMessage | SystemMessage | ToolResultMessage | UserMessage

casual_mcp/models/model_config.py

@@ -0,0 +1,21 @@
+from typing import Literal
+
+from pydantic import BaseModel, HttpUrl
+
+
+class BaseModelConfig(BaseModel):
+    provider: Literal["openai", "ollama"]
+    model: str
+    endpoint: HttpUrl | None = None
+    template: str | None = None
+
+
+class OpenAIModelConfig(BaseModelConfig):
+    provider: Literal["openai"]
+
+
+class OllamaModelConfig(BaseModelConfig):
+    provider: Literal["ollama"]
+
+
+ModelConfig = OpenAIModelConfig | OllamaModelConfig

casual_mcp/models/tool_call.py

@@ -0,0 +1,14 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class AssistantToolCallFunction(BaseModel):
+    name: str
+    arguments: str
+
+
+class AssistantToolCall(BaseModel):
+    id: str
+    type: Literal["function"] = "function"
+    function: AssistantToolCallFunction

casual_mcp/multi_server_mcp_client.py

@@ -0,0 +1,170 @@
+import json
+import os
+
+import mcp
+from fastmcp import Client
+from fastmcp.client.logging import LogMessage
+from fastmcp.client.transports import (
+    ClientTransport,
+    NodeStdioTransport,
+    PythonStdioTransport,
+    StreamableHttpTransport,
+    UvxStdioTransport,
+)
+
+from casual_mcp.logging import get_logger
+from casual_mcp.models.mcp_server_config import McpServerConfig
+from casual_mcp.models.messages import ToolResultMessage
+from casual_mcp.models.tool_call import AssistantToolCall, AssistantToolCallFunction
+from casual_mcp.utils import format_tool_call_result
+
+logger = get_logger("multi_server_mcp_client")
+
+
+async def my_log_handler(params: LogMessage):
+    logger.log(params.level, params.data)
+
+
+def get_server_transport(config: McpServerConfig) -> ClientTransport:
+    match config.type:
+        case 'python':
+            return PythonStdioTransport(
+                script_path=config.path,
+                env=config.env
+            )
+        case 'node':
+            return NodeStdioTransport(
+                script_path=config.path,
+                env=config.env
+            )
+        case 'http':
+            return StreamableHttpTransport(
+                url=config.url
+                )
+        case 'uvx':
+            return UvxStdioTransport(
+                tool_name=config.package,
+                env_vars=config.env
+            )
+
+
+class MultiServerMCPClient:
+    def __init__(self, namespace_tools: bool = False):
+        self.servers: dict[str, Client] = {}  # Map server names to client connections
+        self.tools_map = {}  # Map tool names to server names
+        self.tools: list[mcp.types.Tool] = []
+        self.system_prompts: list[str] = []
+        self.namespace_tools = namespace_tools
+
+    async def load_config(self, config: dict[str, McpServerConfig]):
+        # Load the servers from config
+        logger.info("Loading server config")
+        for name, server_config in config.items():
+            transport = get_server_transport(server_config)
+            await self.connect_to_server(
+                transport,
+                name,
+                system_prompt=server_config.system_prompt
+            )
+
+
+    async def connect_to_server_script(self, path, name, env={}):
+        # Connect via stdio to a local script
+        transport = PythonStdioTransport(
+            script_path=path,
+            env=env,
+        )
+
+        return await self.connect_to_server(transport, name)
+
+    async def connect_to_server(self, server, name, system_prompt: str = None):
+        """Connect to an MCP server and register its tools."""
+        logger.debug(f"Connecting to server {name}")
+
+        async with Client(
+            server,
+            log_handler=my_log_handler,
+        ) as server_client:
+            # Store the connection
+            self.servers[name] = server_client
+
+            # Fetch tools and map them to this server
+            tools = await server_client.list_tools()
+
+            # If we are namespacing servers then change the tool names
+            for tool in tools:
+                if self.namespace_tools:
+                    tool.name = f"{name}-{tool.name}"
+                else:
+                    if self.tools_map.get(tool.name):
+                        raise SystemError(
+                            f"Tool name collision {name}:{tool.name} already added by {self.tools_map[tool.name]}"  # noqa: E501
+                        )
+
+                self.tools_map[tool.name] = name
+            self.tools.extend(tools)
+
+            if system_prompt:
+                prompt = await server_client.get_prompt(system_prompt)
+                if prompt:
+                    self.system_prompts.append(prompt)
+
+            return tools
+
+    async def list_tools(self):
+        """Fetch and aggregate tools from all connected servers."""
+        return self.tools
+
+    async def call_tool(self, function: AssistantToolCallFunction):
+        """Route a tool call to the appropriate server."""
+        tool_name = function.name
+        tool_args = json.loads(function.arguments)
+
+        # Find which server has this tool
+        server_name = self.tools_map.get(tool_name)
+
+        # Remove the sever name if the tools are namespaced
+        if self.namespace_tools:
+            tool_name = tool_name.removeprefix(f"{server_name}-")
+        else:
+            tool_name = tool_name
+
+        if not self.tools_map.get(tool_name):
+            raise ValueError(f"Tool not found: {tool_name}")
+
+        logger.info(f"Calling tool {tool_name}")
+
+        server_client = self.servers[server_name]
+        async with server_client:
+            return await server_client.call_tool(tool_name, tool_args)
+
+
+    async def execute(self, tool_call: AssistantToolCall):
+        try:
+            result = await self.call_tool(tool_call.function)
+        except Exception as e:
+            if isinstance(e, ValueError):
+                logger.warning(e)
+            else:
+                logger.error(f"Error calling tool: {e}")
+
+            return ToolResultMessage(
+                name=tool_call.function.name,
+                tool_call_id=tool_call.id,
+                content=str(e),
+            )
+
+        logger.debug(f"Tool Call Result: {result}")
+
+        result_format = os.getenv('TOOL_RESULT_FORMAT', 'result')
+        content = format_tool_call_result(tool_call, result[0].text, style=result_format)
+
+        return ToolResultMessage(
+            name=tool_call.function.name,
+            tool_call_id=tool_call.id,
+            content=content,
+        )
+
+
+    def get_system_prompts(self) -> list[str]:
+        return self.system_prompts

casual_mcp/providers/abstract_provider.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+
+import mcp
+
+from casual_mcp.models.messages import CasualMcpMessage
+
+
+class CasualMcpProvider(ABC):
+    @abstractmethod
+    async def generate(
+        self,
+        messages: list[CasualMcpMessage],
+        tools: list[mcp.Tool]
+    ) -> CasualMcpMessage:
+        pass