casual-mcp 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

casual_mcp/__init__.py

@@ -1,13 +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
+from .utils import load_config, load_mcp_client, render_system_prompt
 
 __all__ = [
     "McpToolChat",
-    "MultiServerMCPClient",
     "ProviderFactory",
     "load_config",
+    "load_mcp_client",
+    "render_system_prompt",
     "models",
 ]

casual_mcp/cli.py

@@ -3,6 +3,7 @@ import uvicorn
 from rich.console import Console
 from rich.table import Table
 
+from casual_mcp.models.mcp_server_config import RemoteServerConfig
 from casual_mcp.utils import load_config
 
 app = typer.Typer()
@@ -26,23 +27,22 @@ def servers():
     """
     Return a table of all configured servers
     """
-    config = load_config('config.json')
-    table = Table("Name", "Type", "Path / Package / Url", "Env")
+    config = load_config('casual_mcp_config.json')
+    table = Table("Name", "Type", "Command / Url", "Env")
 
     for name, server in config.servers.items():
+        type = 'local'
+        if isinstance(server, RemoteServerConfig):
+            type = 'remote'
+
         path = ''
-        match server.type:
-            case 'python':
-                path = server.path
-            case 'node':
-                path = server.path
-            case 'http':
-                path = server.url
-            case 'uvx':
-                path = server.package
+        if isinstance(server, RemoteServerConfig):
+            path = server.url
+        else:
+            path = f"{server.command} {" ".join(server.args)}"
         env = ''
 
-        table.add_row(name, server.type, path, env)
+        table.add_row(name, type, path, env)
 
     console.print(table)
 
@@ -51,7 +51,7 @@ def models():
     """
     Return a table of all configured models
     """
-    config = load_config('config.json')
+    config = load_config('casual_mcp_config.json')
     table = Table("Name", "Provider", "Model", "Endpoint")
 
     for name, model in config.models.items():

casual_mcp/main.py

@@ -6,16 +6,16 @@ from dotenv import load_dotenv
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel, Field
 
-from casual_mcp import McpToolChat, MultiServerMCPClient
+from casual_mcp import McpToolChat
 from casual_mcp.logging import configure_logging, get_logger
-from casual_mcp.models.messages import CasualMcpMessage
+from casual_mcp.models.messages import ChatMessage
 from casual_mcp.providers.provider_factory import ProviderFactory
-from casual_mcp.utils import load_config, render_system_prompt
+from casual_mcp.utils import load_config, load_mcp_client, render_system_prompt
 
 load_dotenv()
-config = load_config("config.json")
-mcp_client = MultiServerMCPClient(namespace_tools=config.namespace_tools)
-provider_factory = ProviderFactory()
+config = load_config("casual_mcp_config.json")
+mcp_client = load_mcp_client(config)
+provider_factory = ProviderFactory(mcp_client)
 
 app = FastAPI()
 
@@ -32,6 +32,7 @@ You must not speculate or guess about dates — if a date is given to you by a t
 Always present information as current and factual.
 """
 
+
 class GenerateRequest(BaseModel):
     session_id: str | None = Field(
         default=None, title="Session to use"
@@ -42,11 +43,20 @@ class GenerateRequest(BaseModel):
     system_prompt: str | None = Field(
         default=None, title="System Prompt to use"
     )
-    user_prompt: str = Field(
+    prompt: str = Field(
         title="User Prompt"
     )
-    messages: list[CasualMcpMessage] | None = Field(
-        default=None, title="Previous messages to supply to the LLM"
+
+
+class ChatRequest(BaseModel):
+    model: str = Field(
+        title="Model to user"
+    )
+    system_prompt: str | None = Field(
+        default=None, title="System Prompt to use"
+    )
+    messages: list[ChatMessage] = Field(
+        title="Previous messages to supply to the LLM"
     )
 
 sys.path.append(str(Path(__file__).parent.resolve()))
@@ -55,47 +65,11 @@ sys.path.append(str(Path(__file__).parent.resolve()))
 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
-    )
+async def chat(req: ChatRequest):
+    chat = await get_chat(req.model, req.system_prompt)
+    messages = await chat.chat(req.messages)
 
     return {
         "messages": messages,
@@ -103,16 +77,43 @@ async def chat(req: GenerateRequest):
     }
 
 
-# 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)
+async def generate(req: GenerateRequest):
+    chat = await get_chat(req.model, req.system_prompt)
+    messages = await chat.generate(
+        req.prompt,
+        req.session_id
+    )
 
+    return {
+        "messages": messages,
+        "response": messages[len(messages) - 1].content
+    }
 
-@app.get("/chat/session/{session_id}")
-async def get_chat_session(session_id):
+
+@app.get("/generate/session/{session_id}")
+async def get_generate_session(session_id):
     session = McpToolChat.get_session(session_id)
     if not session:
         raise HTTPException(status_code=404, detail="Session not found")
 
     return session
+
+
+async def get_chat(model: str, system: str | None = None) -> McpToolChat:
+    # Get Provider from Model Config
+    model_config = config.models[model]
+    provider = await provider_factory.get_provider(model, model_config)
+
+    # Get the system prompt
+    if not system:
+        if (model_config.template):
+            async with mcp_client:
+                system = render_system_prompt(
+                    f"{model_config.template}.j2",
+                    await mcp_client.list_tools()
+                )
+        else:
+            system = default_system_prompt
+
+    return McpToolChat(mcp_client, provider, system)

casual_mcp/mcp_tool_chat.py

@@ -1,64 +1,102 @@
+import json
+import os
+
+from fastmcp import Client
 
 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.models.messages import (
+    ChatMessage,
+    SystemMessage,
+    ToolResultMessage,
+    UserMessage,
+)
+from casual_mcp.models.tool_call import AssistantToolCall
 from casual_mcp.providers.provider_factory import LLMProvider
+from casual_mcp.utils import format_tool_call_result
 
 logger = get_logger("mcp_tool_chat")
-sessions: dict[str, list[CasualMcpMessage]] = {}
+sessions: dict[str, list[ChatMessage]] = {}
+
+
+def get_session_messages(session_id: str | None):
+    global sessions
+
+    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])}"
+        )
+    return sessions[session_id].copy()
+
+
+def add_messages_to_session(session_id: str, messages: list[ChatMessage]):
+    global sessions
+    sessions[session_id].extend(messages.copy())
 
 
 class McpToolChat:
-    def __init__(self, tool_client: MultiServerMCPClient, provider: LLMProvider, system: str):
+    def __init__(self, mcp_client: Client, provider: LLMProvider, system: str = None):
         self.provider = provider
-        self.tool_client = tool_client
+        self.mcp_client = mcp_client
         self.system = system
 
     @staticmethod
-    def get_session(session_id) -> list[CasualMcpMessage] | None:
+    def get_session(session_id) -> list[ChatMessage] | None:
         global sessions
         return sessions.get(session_id)
 
-    async def chat(
+    async def generate(
         self,
-        prompt: str | None = None,
-        messages: list[CasualMcpMessage] = None,
+        prompt: str,
         session_id: str | None = None
-    ) -> list[CasualMcpMessage]:
-        global sessions
+    ) -> list[ChatMessage]:
+        # Fetch the session if we have a session ID
+        if session_id:
+            messages = get_session_messages(session_id)
+        else:
+            messages: list[ChatMessage] = []
 
-        # todo: check that we have a prompt or that there is a user message in messages
+        # Add the prompt as a user message
+        user_message = UserMessage(content=prompt)
+        messages.append(user_message)
 
-        # If we have a session ID then create if new and fetch it
+        # Add the user message to the session
         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()
+            add_messages_to_session(session_id, [user_message])
 
-        logger.info("Start Chat")
-        tools = await self.tool_client.list_tools()
+        # Perform Chat
+        response = await self.chat(messages=messages)
 
-        if messages is None or len(messages) == 0:
-            message_history = []
-            messages = [SystemMessage(content=self.system)]
-        else:
-            message_history = messages.copy()
+        # Add responses to session
+        if session_id:
+            add_messages_to_session(session_id, response)
+
+        return response
 
-        if prompt:
-            messages.append(UserMessage(content=prompt))
 
-        response: str | None = None
+    async def chat(
+        self,
+        messages: list[ChatMessage]
+    ) -> list[ChatMessage]:
+        # Add a system message if required
+        has_system_message = any(message.role == 'system' for message in messages)
+        if self.system and not has_system_message:
+            # Insert the system message at the start of the messages
+            messages.insert(0, SystemMessage(content=self.system))
+
+        logger.info("Start Chat")
+        async with self.mcp_client:
+            tools = await self.mcp_client.list_tools()
+
+        response_messages: list[ChatMessage] = []
         while True:
             logger.info("Calling the LLM")
             ai_message = await self.provider.generate(messages, tools)
-            response = ai_message.content
 
             # Add the assistant's message
+            response_messages.append(ai_message)
             messages.append(ai_message)
 
             if not ai_message.tool_calls:
@@ -69,22 +107,47 @@ class McpToolChat:
                 result_count = 0
                 for tool_call in ai_message.tool_calls:
                     try:
-                        result = await self.tool_client.execute(tool_call)
+                        result = await self.execute(tool_call)
                     except Exception as e:
                         logger.error(e)
                         return messages
                     if result:
                         messages.append(result)
+                        response_messages.append(result)
                         result_count = result_count + 1
 
                 logger.info(f"Added {result_count} tool results")
 
-        logger.debug(f"""Final Response:
-{response} """)
+        logger.debug(f"Final Response: {response_messages[-1].content}")
 
-        new_messages = [item for item in messages if item not in message_history]
-        if session_id:
-            sessions[session_id].extend(new_messages)
+        return response_messages
+
+
+    async def execute(self, tool_call: AssistantToolCall):
+        tool_name = tool_call.function.name
+        tool_args = json.loads(tool_call.function.arguments)
+        try:
+            async with self.mcp_client:
+                result = await self.mcp_client.call_tool(tool_name, tool_args)
+        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}")
 
-        return new_messages
+        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,
+        )

casual_mcp/models/__init__.py

@@ -1,13 +1,11 @@
 from .mcp_server_config import (
-    HttpMcpServerConfig,
     McpServerConfig,
-    NodeMcpServerConfig,
-    PythonMcpServerConfig,
-    UvxMcpServerConfig,
+    RemoteServerConfig,
+    StdioServerConfig,
 )
 from .messages import (
     AssistantMessage,
-    CasualMcpMessage,
+    ChatMessage,
     SystemMessage,
     ToolResultMessage,
     UserMessage,
@@ -22,12 +20,10 @@ __all__ = [
     "AssistantMessage",
     "ToolResultMessage",
     "SystemMessage",
-    "CasualMcpMessage",
+    "ChatMessage",
     "ModelConfig",
     "OpenAIModelConfig",
     "McpServerConfig",
-    "PythonMcpServerConfig",
-    "UvxMcpServerConfig",
-    "NodeMcpServerConfig",
-    "HttpMcpServerConfig",
+    "StdioServerConfig",
+    "RemoteServerConfig",
 ]

casual_mcp/models/mcp_server_config.py

@@ -1,39 +1,20 @@
-from typing import Literal
+from typing import Any, Literal
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
-class BaseMcpServerConfig(BaseModel):
-    type: Literal["python", "node", "http", "uvx"]
-    system_prompt: str | None | None = None
+class StdioServerConfig(BaseModel):
+    command: str
+    args: list[str] = Field(default_factory=list)
+    env: dict[str, Any] = Field(default_factory=dict)
+    cwd: str | None = None
+    transport: Literal["stdio"] = "stdio"
 
 
-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"
+class RemoteServerConfig(BaseModel):
     url: str
+    headers: dict[str, str] = Field(default_factory=dict)
+    transport: Literal["streamable-http", "sse", "http"] | None = None
 
 
-McpServerConfig = (
-    PythonMcpServerConfig
-    | NodeMcpServerConfig
-    | HttpMcpServerConfig
-    | UvxMcpServerConfig
-)
+McpServerConfig = StdioServerConfig | RemoteServerConfig

casual_mcp/models/messages.py

@@ -28,4 +28,4 @@ class UserMessage(BaseModel):
     content: str | None
 
 
-CasualMcpMessage: TypeAlias = AssistantMessage | SystemMessage | ToolResultMessage | UserMessage
+ChatMessage: TypeAlias = AssistantMessage | SystemMessage | ToolResultMessage | UserMessage

casual_mcp/providers/abstract_provider.py

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

casual_mcp/providers/ollama_provider.py

@@ -6,7 +6,7 @@ from ollama import ChatResponse, Client, ResponseError
 
 from casual_mcp.logging import get_logger
 from casual_mcp.models.generation_error import GenerationError
-from casual_mcp.models.messages import AssistantMessage, CasualMcpMessage
+from casual_mcp.models.messages import AssistantMessage, ChatMessage
 from casual_mcp.providers.abstract_provider import CasualMcpProvider
 
 logger = get_logger("providers.ollama")
@@ -15,7 +15,7 @@ def convert_tools(mcp_tools: list[mcp.Tool]) -> list[ollama.Tool]:
     raise Exception({"message": "under development"})
 
 
-def convert_messages(messages: list[CasualMcpMessage]) -> list[ollama.Message]:
+def convert_messages(messages: list[ChatMessage]) -> list[ollama.Message]:
     raise Exception({"message": "under development"})
 
 
@@ -32,9 +32,9 @@ class OllamaProvider(CasualMcpProvider):
 
     async def generate(
         self,
-        messages: list[CasualMcpMessage],
+        messages: list[ChatMessage],
         tools: list[mcp.Tool]
-    ) -> CasualMcpMessage:
+    ) -> ChatMessage:
         logger.info("Start Generating")
         logger.debug(f"Model: {self.model}")
 

casual_mcp/providers/openai_provider.py

@@ -15,7 +15,7 @@ from openai.types.chat import (
 
 from casual_mcp.logging import get_logger
 from casual_mcp.models.generation_error import GenerationError
-from casual_mcp.models.messages import AssistantMessage, CasualMcpMessage
+from casual_mcp.models.messages import AssistantMessage, ChatMessage
 from casual_mcp.models.tool_call import AssistantToolCall, AssistantToolCallFunction
 from casual_mcp.providers.abstract_provider import CasualMcpProvider
 
@@ -59,7 +59,7 @@ def convert_tool(mcp_tool: mcp.Tool) -> ChatCompletionToolParam | None:
     return ChatCompletionToolParam(**tool)
 
 
-def convert_messages(messages: list[CasualMcpMessage]) -> list[ChatCompletionMessageParam]:
+def convert_messages(messages: list[ChatMessage]) -> list[ChatCompletionMessageParam]:
     if not messages:
         return messages
 
@@ -144,7 +144,7 @@ class OpenAiProvider(CasualMcpProvider):
 
     async def generate(
         self,
-        messages: list[CasualMcpMessage],
+        messages: list[ChatMessage],
         tools: list[mcp.Tool]
     ) -> AssistantMessage:
         logger.info("Start Generating")

casual_mcp/providers/provider_factory.py

@@ -2,6 +2,7 @@ import os
 from typing import TypeAlias
 
 import mcp
+from fastmcp import Client
 
 from casual_mcp.logging import get_logger
 from casual_mcp.models.model_config import ModelConfig
@@ -13,15 +14,22 @@ logger = get_logger("providers.factory")
 LLMProvider: TypeAlias = OpenAiProvider | OllamaProvider
 
 class ProviderFactory:
-    def __init__(self):
-        self.providers: dict[str, LLMProvider] = {}
+    providers: dict[str, LLMProvider] = {}
+    tools: list[mcp.Tool] = None
+
+    def __init__(self, mcp_client: Client):
+        self.mcp_client = mcp_client
 
 
     def set_tools(self, tools: list[mcp.Tool]):
         self.tools = tools
 
 
-    def get_provider(self, name: str, config: ModelConfig) -> LLMProvider:
+    async def get_provider(self, name: str, config: ModelConfig) -> LLMProvider:
+        if not self.tools:
+            async with self.mcp_client:
+                self.tools = await self.mcp_client.list_tools()
+
         if self.providers.get(name):
             return self.providers.get(name)
 

casual_mcp/utils.py

@@ -2,6 +2,7 @@ import json
 from pathlib import Path
 
 import mcp
+from fastmcp import Client
 from jinja2 import Environment, FileSystemLoader
 from pydantic import ValidationError
 
@@ -9,6 +10,14 @@ from casual_mcp.models.config import Config
 from casual_mcp.models.tool_call import AssistantToolCall
 
 
+def load_mcp_client(config: Config) -> Client:
+    servers = {
+        key: value.model_dump()
+        for key, value in config.servers.items()
+    }
+    return Client(servers)
+
+
 def load_config(path: str | Path) -> Config:
     path = Path(path)
 

{casual_mcp-0.1.0.dist-info → casual_mcp-0.3.0.dist-info}/METADATA

@@ -1,16 +1,18 @@
 Metadata-Version: 2.4
 Name: casual-mcp
-Version: 0.1.0
+Version: 0.3.0
 Summary: Multi-server MCP client for LLM tool orchestration
 Author: Alex Stansfield
 License: MIT
+Project-URL: Homepage, https://github.com/AlexStansfield/casual-mcp
+Project-URL: Repository, https://github.com/AlexStansfield/casual-mcp
+Project-URL: Issue Tracker, https://github.com/AlexStansfield/casual-mcp/issues
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: amadeus>=12.0.0
 Requires-Dist: dateparser>=1.2.1
 Requires-Dist: fastapi>=0.115.12
-Requires-Dist: fastmcp>=2.3.4
+Requires-Dist: fastmcp>=2.5.1
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: ollama>=0.4.8
 Requires-Dist: openai>=1.78.0
@@ -34,7 +36,7 @@ Dynamic: license-file
 **Casual MCP** is a Python framework for building, evaluating, and serving LLMs with tool-calling capabilities using [Model Context Protocol (MCP)](https://modelcontextprotocol.io).  
 It includes:
 
-- ✅ A multi-server MCP client
+- ✅ A multi-server MCP client using [FastMCP](https://github.com/jlowin/fastmcp)
 - ✅ Provider support for OpenAI (and OpenAI compatible APIs)
 - ✅ A recursive tool-calling chat loop
 - ✅ System prompt templating with Jinja2
@@ -98,11 +100,11 @@ Here is a list of functions in JSON format that you can invoke:
 ]
 ```
 
-## ⚙️ Configuration File (`config.json`)
+## ⚙️ Configuration File (`casual_mcp_config.json`)
 
 📄 See the [Programmatic Usage](#-programmatic-usage) section to build configs and messages with typed models.
 
-The CLI and API can be configured using a `config.json` file that defines:
+The CLI and API can be configured using a `casual_mcp_config.json` file that defines:
 
 - 🔧 Available **models** and their providers
 - 🧰 Available **MCP tool servers**
@@ -112,7 +114,6 @@ The CLI and API can be configured using a `config.json` file that defines:
 
 ```json
 {
-  "namespaced_tools": false,
   "models": {
     "lm-qwen-3": {
       "provider": "openai",
@@ -127,11 +128,10 @@ The CLI and API can be configured using a `config.json` file that defines:
   },
   "servers": {
     "time": {
-      "type": "python",
-      "path": "mcp-servers/time/server.py"
+      "command": "python",
+      "args": ["mcp-servers/time/server.py"]
     },
     "weather": {
-      "type": "http",
       "url": "http://localhost:5050/mcp"
     }
   }
@@ -142,25 +142,31 @@ The CLI and API can be configured using a `config.json` file that defines:
 
 Each model has:
 
-- `provider`: `"openai"` or `"ollama"`
+- `provider`: `"openai"` (more to come)
 - `model`: the model name (e.g., `gpt-4.1`, `qwen3-8b`)
 - `endpoint`: required for custom OpenAI-compatible backends (e.g., LM Studio)
 - `template`: optional name used to apply model-specific tool calling formatting
 
 ### 🔹 `servers`
 
-Each server has:
+Servers can either be local (over stdio) or remote.
 
-- `type`: `"python"`, `"http"`, `"node"`, or `"uvx"`
-- For `python`/`node`: `path` to the script
-- For `http`: `url` to the remote MCP endpoint
-- For `uvx`: `package` for the package to run
-- Optional: `env` for subprocess environments, `system_prompt` to override server prompt
+#### Local Config:
+- `command`: the command to run the server, e.g `python`, `npm`
+- `args`: the arguments to pass to the server as a list, e.g `["time/server.py"]`
+- Optional: `env`: for subprocess environments, `system_prompt` to override server prompt
 
-### 🔹 `namespaced_tools`
+#### Remote Config:
+- `url`: the url of the mcp server
+- Optional: `transport`: the type of transport, `http`, `sse`, `streamable-http`. Defaults to `http`
 
-If `true`, tools will be prefixed by server name (e.g., `weather-get_weather`).  
-Useful for disambiguating tool names across servers and avoiding name collision if multiple servers have the same tool name.
+## Environmental Variables
+
+There are two environmental variables:
+- `OPEN_AI_API_KEY`: required when using the `openai` provider, if using a local model with an openai compatible API it can be any string
+- `TOOL_RESULT_FORMAT`: adjusts the format of the tool result given back to the LLM. Options are `result`, `function_result`, `function_args_result`. Defaults to `result`
+
+You can set them using `export` or by creating a `.env` file.
 
 ## 🛠 CLI Reference
 
@@ -178,12 +184,12 @@ Loads the config and outputs the list of MCP servers you have configured.
 ```
 $ casual-mcp servers
 ┏━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━┓
-┃ Name    ┃ Type   ┃ Path / Package / Url          ┃ Env ┃
+┃ Name    ┃ Type   ┃ Command / Url                 ┃ Env ┃
 ┡━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━┩
-│ math    │ python │ mcp-servers/math/server.py    │     │
-│ time    │ python │ mcp-servers/time-v2/server.py │     │
-│ weather │ python │ mcp-servers/weather/server.py │     │
-│ words   │ python │ mcp-servers/words/server.py   │     │
+│ math    │ local  │ mcp-servers/math/server.py    │     │
+│ time    │ local  │ mcp-servers/time-v2/server.py │     │
+│ weather │ local  │ mcp-servers/weather/server.py │     │
+│ words   │ remote │ https://localhost:3000/mcp    │     │
 └─────────┴────────┴───────────────────────────────┴─────┘
 ```
 
@@ -217,57 +223,68 @@ Orchestrates LLM interaction with tools using a recursive loop.
 
 ```python
 from casual_mcp import McpToolChat
+from casual_mcp.models import SystemMessage, UserMessage
 
 chat = McpToolChat(mcp_client, provider, system_prompt)
-response = await chat.chat(prompt="What time is it in London?")
-```
 
-#### `MultiServerMCPClient`
-Connects to multiple MCP tool servers and manages available tools.
+# Generate method to take user prompt
+response = await chat.generate("What time is it in London?")
 
-```python
-from casual_mcp import MultiServerMCPClient
+# Generate method with session
+response = await chat.generate("What time is it in London?", "my-session-id")
 
-mcp_client = MultiServerMCPClient()
-await mcp_client.load_config(config["servers"])
-tools = await mcp_client.list_tools()
+# Chat method that takes list of chat messages 
+# note: system prompt ignored if sent in messages so no need to set
+chat = McpToolChat(mcp_client, provider) 
+messages = [
+  SystemMessage(content="You are a cool dude who likes to help the user"),
+  UserMessage(content="What time is it in London?")
+]
+response = await chat.chat(messages)
 ```
 
 #### `ProviderFactory`
 Instantiates LLM providers based on the selected model config.
 
 ```python
-from casual_mcp.providers.provider_factory import ProviderFactory
+from casual_mcp import ProviderFactory
 
-provider_factory = ProviderFactory()
-provider = provider_factory.get_provider("lm-qwen-3", model_config)
+provider_factory = ProviderFactory(mcp_client)
+provider = await provider_factory.get_provider("lm-qwen-3", model_config)
 ```
 
 #### `load_config`
-Loads your `config.json` into a validated config object.
+Loads your `casual_mcp_config.json` into a validated config object.
 
 ```python
-from casual_mcp.utils import load_config
+from casual_mcp import load_config
 
-config = load_config("config.json")
+config = load_config("casual_mcp_config.json")
+```
+
+#### `load_mcp_client`
+Creats a multi server FastMCP client from the config object
+
+```python
+from casual_mcp import load_mcp_client
+
+config = load_mcp_client(config)
 ```
 
 #### Model and Server Configs
 
 Exported models:
-- PythonMcpServerConfig
-- UvxMcpServerConfig
-- NodeMcpServerConfig
-- HttpMcpServerConfig
+- StdioServerConfig
+- RemoteServerConfig
 - OpenAIModelConfig
 
 Use these types to build valid configs:
 
 ```python
-from casual_mcp.models import OpenAIModelConfig, PythonMcpServerConfig
+from casual_mcp.models import OpenAIModelConfig, StdioServerConfig
 
-model = OpenAIModelConfig( model="llama3", endpoint="http://...")
-server = PythonMcpServerConfig(path="time/server.py")
+model = OpenAIModelConfig(model="llama3", endpoint="http://...")
+server = StdioServerConfig(command="python", args=["time/server.py"])
 ```
 
 #### Chat Messages
@@ -292,7 +309,7 @@ messages = [
 ### Example
 
 ```python
-from casual_mcp import McpToolChat, MultiServerMCPClient, load_config, ProviderFactory
+from casual_mcp import McpToolChat, load_config, load_mcp_client, ProviderFactory
 from casual_mcp.models import SystemMessage, UserMessage
 
 model = "gpt-4.1-nano"
@@ -304,20 +321,18 @@ Respond naturally and confidently, as if you already know all the facts."""),
 ]
 
 # Load the Config from the File
-config = load_config("config.json")
+config = load_config("casual_mcp_config.json")
 
-# Setup the MultiServer MCP Client
-mcp_client = MultiServerMCPClient()
-await mcp_client.load_config(config.servers)
+# Setup the MCP Client
+mcp_client = load_mcp_client(config)
 
 # Get the Provider for the Model
-provider_factory.set_tools(await mcp_client.list_tools())
-provider_factory = ProviderFactory()
-provider = provider_factory.get_provider(model, config.models[model])
+provider_factory = ProviderFactory(mcp_client)
+provider = await provider_factory.get_provider(model, config.models[model])
 
 # Perform the Chat and Tool calling
-chat = McpToolChat(mcp_client, provider, system_prompt)
-response_messages = await chat.chat(messages=messages)
+chat = McpToolChat(mcp_client, provider)
+response_messages = await chat.chat(messages)
 ```
 
 ## 🚀 API Usage
@@ -328,25 +343,56 @@ response_messages = await chat.chat(messages=messages)
 casual-mcp serve --host 0.0.0.0 --port 8000
 ```
 
-You can then POST to `/chat` to trigger tool-calling LLM responses.
+### Chat
+
+#### Endpoint: `POST /chat`
 
-The request takes a json body consisting of:
+#### Request Body:
 - `model`: the LLM model to use
-- `user_prompt`: optional, the latest user message (required if messages isn't provided)
-- `messages`: optional, list of chat messages (system, assistant, user, etc) that you can pass to the api, allowing you to keep your own chat session in the client calling the api
-- `session_id`: an optional ID that stores all the messages from the session and provides them back to the LLM for context
+- `messages`: list of chat messages (system, assistant, user, etc) that you can pass to the api, allowing you to keep your own chat session in the client calling the api
 
-You can either pass in a `user_prompt` or a list of `messages` depending on your use case.
+#### Example:
+```
+{
+    "model": "gpt-4.1-nano",
+    "messages": [
+        {
+            "role": "user",
+            "content": "can you explain what the word consistent means?"
+        }
+    ]
+}
+```
+
+### Generate
+
+The generate endpoint allows you to send a user prompt as a string. 
+
+It also support sessions that keep a record of all messages in the session and feeds them back into the LLM for context. Sessions are stored in memory so are cleared when the server is restarted
+
+#### Endpoint: `POST /generate`
 
-Example:
+####  Request Body:
+- `model`: the LLM model to use
+- `prompt`: the user prompt 
+- `session_id`: an optional ID that stores all the messages from the session and provides them back to the LLM for context
+
+#### Example:
 ```
 {
-    "session_id": "my-test-session",
+    "session_id": "my-session",
     "model": "gpt-4o-mini",
-    "user_prompt": "can you explain what the word consistent means?"
+    "prompt": "can you explain what the word consistent means?"
 }
 ```
 
+### Get Session
+
+Get all the messages from a session 
+
+#### Endpoint: `GET /generate/session/{session_id}`
+
+
 ## License
 
 This software is released under the [MIT License](LICENSE)

casual_mcp-0.3.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+casual_mcp/__init__.py,sha256=pInJdGkFqSH8RwbQq-9mc96GWIQjLrtExeXnTYGtNHw,327
+casual_mcp/cli.py,sha256=TSk12nXJH86f0WAR_u5hIJV9IAHeGHrkgFs7ZZ63Lug,1627
+casual_mcp/logging.py,sha256=o3rvT8GLJKGlu0ieeC9TY_SRSEUY-VO8jRQZjx-sSvY,863
+casual_mcp/main.py,sha256=AzqQ6SUJsyKyMaqd3HIxLDozoftMd27KQAQNsfM9e2I,3385
+casual_mcp/mcp_tool_chat.py,sha256=BebLuo2F4nStd4vVO3BftfG8Sa6Zlx11UBuMezpbtIE,4897
+casual_mcp/utils.py,sha256=Nea0aRbPyjqm7mIjffJtGP2NssE7BsdPleO-yiuAWPE,2964
+casual_mcp/models/__init__.py,sha256=qlKylcCyRJOSIVteU2feiLOigZoY-m-soVGp4NALM_c,538
+casual_mcp/models/config.py,sha256=ITu3WAPMad7i2CS3ljkHapjT8lLm7k6HFUF6N73U1oo,294
+casual_mcp/models/generation_error.py,sha256=n1mF3vc1Sg_9yIe603G1nTP395Tht8JMKHqdMWFNAn0,259
+casual_mcp/models/mcp_server_config.py,sha256=0OHsHUEKxRoCl21lsye4E5GoCNmdZWIZCOOthcTpdsE,539
+casual_mcp/models/messages.py,sha256=7C0SoCC6Ee970iHprpCpsKsQrwvM66e39o96wfYm1Y8,683
+casual_mcp/models/model_config.py,sha256=gN5hNDfbur_bHgrji87CcU2WgNZO-F3eveK4pVWVSAE,435
+casual_mcp/models/tool_call.py,sha256=BKMxcmyW7EmNoG1jgS9PXXvf6RQIHf7wB8fElEbc4gA,271
+casual_mcp/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+casual_mcp/providers/abstract_provider.py,sha256=TTEP3FeTxOtbD0By_k17UxS8cqxYCOGNRTRxYRrqGwc,292
+casual_mcp/providers/ollama_provider.py,sha256=IUSJFBtEYmza_-_7bk5YZKqed3N67l8A2lZEmHPiyHo,2581
+casual_mcp/providers/openai_provider.py,sha256=uSjoqM-X9bVp_RVM8Ip6lqjZ7q3DdN0-p7o2HKrWxMI,6138
+casual_mcp/providers/provider_factory.py,sha256=CyFHJ0mU2tjHqj04btF0SL0B3pf12LAJ52Msqsbnv_g,1766
+casual_mcp-0.3.0.dist-info/licenses/LICENSE,sha256=U3Zu2tkrh5vXdy7gIdE8WJGM9D4gGp3hohAAWdre-yo,1058
+casual_mcp-0.3.0.dist-info/METADATA,sha256=ULZbRBwX0FVKjfS2pPu3JWwvD5btiIkA6qOqWoWRa_0,12902
+casual_mcp-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+casual_mcp-0.3.0.dist-info/entry_points.txt,sha256=X48Np2cwl-SlRQdV26y2vPZ-2tJaODgZeVtfpHho-zg,50
+casual_mcp-0.3.0.dist-info/top_level.txt,sha256=K4CiI0Jf8PHICjuQVm32HuNMB44kp8Lb02bbbdiH5bo,11
+casual_mcp-0.3.0.dist-info/RECORD,,

{casual_mcp-0.1.0.dist-info → casual_mcp-0.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

casual_mcp/multi_server_mcp_client.py

@@ -1,170 +0,0 @@
-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-0.1.0.dist-info/RECORD

@@ -1,25 +0,0 @@
-casual_mcp/__init__.py,sha256=UZTKF9qlKijDh2SRCbpz6nPi0now7hi4-VOJBnl7tTk,323
-casual_mcp/cli.py,sha256=s5-Mr2XNlzNcsfGwtwP25YBQYzf-orvDIu9gqwrVCI8,1561
-casual_mcp/logging.py,sha256=o3rvT8GLJKGlu0ieeC9TY_SRSEUY-VO8jRQZjx-sSvY,863
-casual_mcp/main.py,sha256=x-jJUltW4p4j0Vx-LaixbY0Oik6QZ81K2wdDeTNytME,3497
-casual_mcp/mcp_tool_chat.py,sha256=pIAQD-ghyLSGuLzXiG5Sv81-NHaNb5NVqRojJalwS1o,3113
-casual_mcp/multi_server_mcp_client.py,sha256=RrLO7wFGzkUgzmliagkOAx16lrvEG323MGPEU7Sw56o,5615
-casual_mcp/utils.py,sha256=8ekPpIfcqheMMjjKGe6lk81AWKpmCAixOXx_KJXGRAQ,2758
-casual_mcp/models/__init__.py,sha256=hHT-GBD0YMjHdJ4QGVefXQZsHu3bPd1vlizVdfYXoQ0,660
-casual_mcp/models/config.py,sha256=ITu3WAPMad7i2CS3ljkHapjT8lLm7k6HFUF6N73U1oo,294
-casual_mcp/models/generation_error.py,sha256=n1mF3vc1Sg_9yIe603G1nTP395Tht8JMKHqdMWFNAn0,259
-casual_mcp/models/mcp_server_config.py,sha256=o4uxq9JnrLRRHe0KNsaYE3P03wJdW1EmX18fmF7SoTQ,857
-casual_mcp/models/messages.py,sha256=5UASrYqlXeqaziDT8Zsej0kA7Ofce0109YlFAyQDuTY,688
-casual_mcp/models/model_config.py,sha256=gN5hNDfbur_bHgrji87CcU2WgNZO-F3eveK4pVWVSAE,435
-casual_mcp/models/tool_call.py,sha256=BKMxcmyW7EmNoG1jgS9PXXvf6RQIHf7wB8fElEbc4gA,271
-casual_mcp/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-casual_mcp/providers/abstract_provider.py,sha256=kACSVgPY9qTqD1IgIWY9HkS8US2B0Nm7MyGJk0GLfDk,307
-casual_mcp/providers/ollama_provider.py,sha256=DKX9QTDl9DspWJSghuQgOzHZgjmTVtf5uyRH_DeOgQc,2601
-casual_mcp/providers/openai_provider.py,sha256=VIymU3Jimncne0c1fyowy4BFBpyfK70eG-2rP_YGDzc,6153
-casual_mcp/providers/provider_factory.py,sha256=Bub4y4uHFc23VCOeRicT_Fi54IdcjHUgYAWPo1oiSo4,1519
-casual_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=U3Zu2tkrh5vXdy7gIdE8WJGM9D4gGp3hohAAWdre-yo,1058
-casual_mcp-0.1.0.dist-info/METADATA,sha256=PCJXGER8P8MgnqNBNRPVSysqumU4654KfUpUUyNLEdE,11576
-casual_mcp-0.1.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-casual_mcp-0.1.0.dist-info/entry_points.txt,sha256=X48Np2cwl-SlRQdV26y2vPZ-2tJaODgZeVtfpHho-zg,50
-casual_mcp-0.1.0.dist-info/top_level.txt,sha256=K4CiI0Jf8PHICjuQVm32HuNMB44kp8Lb02bbbdiH5bo,11
-casual_mcp-0.1.0.dist-info/RECORD,,