casual-mcp 0.1.0__tar.gz → 0.3.0__tar.gz

{casual_mcp-0.1.0/src/casual_mcp.egg-info → casual_mcp-0.3.0}/PKG-INFO

@@ -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.1.0 → casual_mcp-0.3.0}/README.md

@@ -6,7 +6,7 @@
 **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
@@ -70,11 +70,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**
@@ -84,7 +84,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",
@@ -99,11 +98,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"
     }
   }
@@ -114,25 +112,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
 
@@ -150,12 +154,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    │     │
 └─────────┴────────┴───────────────────────────────┴─────┘
 ```
 
@@ -189,57 +193,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
@@ -264,7 +279,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"
@@ -276,20 +291,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
@@ -300,25 +313,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.1.0 → casual_mcp-0.3.0}/pyproject.toml

@@ -1,16 +1,15 @@
 [project]
 name = "casual-mcp"
-version = "0.1.0"
+version = "0.3.0"
 description = "Multi-server MCP client for LLM tool orchestration"
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT" }
 authors = [{ name = "Alex Stansfield" }]
 dependencies = [
-    "amadeus>=12.0.0",
     "dateparser>=1.2.1",
     "fastapi>=0.115.12",
-    "fastmcp>=2.3.4",
+    "fastmcp>=2.5.1",
     "jinja2>=3.1.6",
     "ollama>=0.4.8",
     "openai>=1.78.0",
@@ -20,6 +19,11 @@ dependencies = [
     "uvicorn>=0.34.2",
 ]
 
+[project.urls]
+"Homepage" = "https://github.com/AlexStansfield/casual-mcp"
+"Repository" = "https://github.com/AlexStansfield/casual-mcp"
+"Issue Tracker" = "https://github.com/AlexStansfield/casual-mcp/issues"
+
 [project.optional-dependencies]
 dev = [
     "ruff",
@@ -59,3 +63,12 @@ dev = [
     "pytest>=8.3.5",
     "ruff>=0.11.10",
 ]
+
+[tool.bumpversion]
+current_version = "0.3.0"
+commit = true
+tag = true
+
+[tool.bumpversion.file."pyproject.toml"]
+search = 'version = "{current_version}"'
+replace = 'version = "{new_version}"'

{casual_mcp-0.1.0 → casual_mcp-0.3.0}/src/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",
 ]