casual-mcp 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

casual_mcp/__init__.py

@@ -1,12 +1,13 @@
 from . import models
 from .mcp_tool_chat import McpToolChat
 from .providers.provider_factory import ProviderFactory
-from .utils import load_config, load_mcp_client
+from .utils import load_config, load_mcp_client, render_system_prompt
 
 __all__ = [
     "McpToolChat",
     "ProviderFactory",
     "load_config",
     "load_mcp_client",
+    "render_system_prompt",
     "models",
 ]

casual_mcp/cli.py

@@ -1,10 +1,11 @@
+import asyncio
 import typer
 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
+from casual_mcp.utils import load_config, load_mcp_client
 
 app = typer.Typer()
 console = Console()
@@ -31,7 +32,7 @@ def servers():
     table = Table("Name", "Type", "Command / Url", "Env")
 
     for name, server in config.servers.items():
-        type = 'local'
+        type = 'stdio'
         if isinstance(server, RemoteServerConfig):
             type = 'remote'
 
@@ -39,7 +40,7 @@ def servers():
         if isinstance(server, RemoteServerConfig):
             path = server.url
         else:
-            path = f"{server.command} {" ".join(server.args)}"
+            path = f"{server.command} {' '.join(server.args)}"
         env = ''
 
         table.add_row(name, type, path, env)
@@ -63,6 +64,21 @@ def models():
 
     console.print(table)
 
+@app.command()
+def tools():
+    config = load_config('casual_mcp_config.json')
+    mcp_client = load_mcp_client(config)
+    table = Table("Name", "Description")
+    # async with mcp_client:
+    tools = asyncio.run(get_tools(mcp_client))
+    for tool in tools:
+        table.add_row(tool.name, tool.description)
+    console.print(table)
+
+
+async def get_tools(client):
+    async with client:
+        return await client.list_tools()
 
 if __name__ == "__main__":
     app()

casual_mcp/main.py

@@ -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[ChatMessage] | 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,44 +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[ChatMessage] = None,
-    session_id: str | None = None
-) -> list[ChatMessage]:
-    # Get Provider from Model Config
-    model_config = config.models[model]
-    provider = await provider_factory.get_provider(model, model_config)
-
-    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
-
-    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):
-    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,
@@ -100,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

@@ -18,8 +18,26 @@ logger = get_logger("mcp_tool_chat")
 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, mcp_client: Client, provider: LLMProvider, system: str):
+    def __init__(self, mcp_client: Client, provider: LLMProvider, system: str = None):
         self.provider = provider
         self.mcp_client = mcp_client
         self.system = system
@@ -29,47 +47,57 @@ class McpToolChat:
         global sessions
         return sessions.get(session_id)
 
-    async def chat(
+    async def generate(
         self,
-        prompt: str | None = None,
-        messages: list[ChatMessage] = None,
+        prompt: str,
         session_id: str | None = None
     ) -> list[ChatMessage]:
-        global sessions
+        # 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])
+
+        # Perform Chat
+        response = await self.chat(messages=messages)
+
+        # Add responses to session
+        if session_id:
+            add_messages_to_session(session_id, response)
+
+        return response
+
+
+    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
+            logger.debug(f"Adding System Message")
+            messages.insert(0, SystemMessage(content=self.system))
 
         logger.info("Start Chat")
         async with self.mcp_client:
             tools = await self.mcp_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
+        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:
@@ -86,18 +114,14 @@ class McpToolChat:
                         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} """)
-
-        new_messages = [item for item in messages if item not in message_history]
-        if session_id:
-            sessions[session_id].extend(new_messages)
+        logger.debug(f"Final Response: {response_messages[-1].content}")
 
-        return new_messages
+        return response_messages
 
 
     async def execute(self, tool_call: AssistantToolCall):

{casual_mcp-0.2.2.dist-info → casual_mcp-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casual-mcp
-Version: 0.2.2
+Version: 0.3.1
 Summary: Multi-server MCP client for LLM tool orchestration
 Author: Alex Stansfield
 License: MIT
@@ -12,7 +12,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: dateparser>=1.2.1
 Requires-Dist: fastapi>=0.115.12
-Requires-Dist: fastmcp>=2.5.1
+Requires-Dist: fastmcp>=2.5.2
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: ollama>=0.4.8
 Requires-Dist: openai>=1.78.0
@@ -36,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
@@ -151,12 +151,12 @@ Each model has:
 
 Servers can either be local (over stdio) or remote.
 
-Local Config:
+#### 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
 
-Remote Config:
+#### Remote Config:
 - `url`: the url of the mcp server
 - Optional: `transport`: the type of transport, `http`, `sse`, `streamable-http`. Defaults to `http`
 
@@ -184,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    │     │
 └─────────┴────────┴───────────────────────────────┴─────┘
 ```
 
@@ -223,9 +223,24 @@ 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?")
+
+# Generate method to take user prompt
+response = await chat.generate("What time is it in London?")
+
+# Generate method with session
+response = await chat.generate("What time is it in London?", "my-session-id")
+
+# 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`
@@ -234,8 +249,8 @@ Instantiates LLM providers based on the selected model config.
 ```python
 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`
@@ -308,18 +323,16 @@ Respond naturally and confidently, as if you already know all the facts."""),
 # Load the Config from the File
 config = load_config("casual_mcp_config.json")
 
-# Setup the MultiServer MCP Client
+# Setup the MCP Client
 mcp_client = load_mcp_client(config)
-await mcp_client.load_config(config.servers)
 
 # 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
@@ -330,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
+
+#### 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`
 
-You can either pass in a `user_prompt` or a list of `messages` depending on your use case.
+####  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:
+#### 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.2.2.dist-info → casual_mcp-0.3.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
-casual_mcp/__init__.py,sha256=qL2sZhhWrp60taGBHUG1yeelUgpxld-qXFEbEUMXZVM,277
-casual_mcp/cli.py,sha256=TSk12nXJH86f0WAR_u5hIJV9IAHeGHrkgFs7ZZ63Lug,1627
+casual_mcp/__init__.py,sha256=pInJdGkFqSH8RwbQq-9mc96GWIQjLrtExeXnTYGtNHw,327
+casual_mcp/cli.py,sha256=6P_d77qPbY43AW1Ix6FfbHyy6Qc6sFeFqGvXxJCW2_M,2090
 casual_mcp/logging.py,sha256=o3rvT8GLJKGlu0ieeC9TY_SRSEUY-VO8jRQZjx-sSvY,863
-casual_mcp/main.py,sha256=1t702JABc1sFBzic7TMPE6OrikizBfOnlRpaY84p7oQ,3358
-casual_mcp/mcp_tool_chat.py,sha256=5PcbacNj3HR13Rnz4TDhxOtxfipNqGMgyTKHsaSAnV4,4249
+casual_mcp/main.py,sha256=AzqQ6SUJsyKyMaqd3HIxLDozoftMd27KQAQNsfM9e2I,3385
+casual_mcp/mcp_tool_chat.py,sha256=6MMRAEBDMRyw7-n1VGvIGdrh1ed2szZx8sC0MlR1g7I,4948
 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
@@ -16,9 +16,9 @@ casual_mcp/providers/abstract_provider.py,sha256=TTEP3FeTxOtbD0By_k17UxS8cqxYCOG
 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.2.2.dist-info/licenses/LICENSE,sha256=U3Zu2tkrh5vXdy7gIdE8WJGM9D4gGp3hohAAWdre-yo,1058
-casual_mcp-0.2.2.dist-info/METADATA,sha256=z9WtBJF17iSjFXzj3vBIIK786LGO7Lx6VYv8SZGtX54,11954
-casual_mcp-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-casual_mcp-0.2.2.dist-info/entry_points.txt,sha256=X48Np2cwl-SlRQdV26y2vPZ-2tJaODgZeVtfpHho-zg,50
-casual_mcp-0.2.2.dist-info/top_level.txt,sha256=K4CiI0Jf8PHICjuQVm32HuNMB44kp8Lb02bbbdiH5bo,11
-casual_mcp-0.2.2.dist-info/RECORD,,
+casual_mcp-0.3.1.dist-info/licenses/LICENSE,sha256=U3Zu2tkrh5vXdy7gIdE8WJGM9D4gGp3hohAAWdre-yo,1058
+casual_mcp-0.3.1.dist-info/METADATA,sha256=uqtEAq3-YfRInCxU79bwfBhrsGxFKbvUWAJ7D0XTA0g,12902
+casual_mcp-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+casual_mcp-0.3.1.dist-info/entry_points.txt,sha256=X48Np2cwl-SlRQdV26y2vPZ-2tJaODgZeVtfpHho-zg,50
+casual_mcp-0.3.1.dist-info/top_level.txt,sha256=K4CiI0Jf8PHICjuQVm32HuNMB44kp8Lb02bbbdiH5bo,11
+casual_mcp-0.3.1.dist-info/RECORD,,