codemie-mcp-assistants 0.1.4__tar.gz → 0.1.5__tar.gz

codemie_mcp_assistants-0.1.5/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.1
+Name: codemie-mcp-assistants
+Version: 0.1.5
+Summary: MCP server for connecting to CodeMie Assistants API
+Author: Vadym Vlasenko
+Author-email: vadym_vlasenko@epam.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: certifi (>=2025.1.31,<2026.0.0)
+Requires-Dist: codemie-sdk-python (==0.1.5)
+Requires-Dist: httpx (>=0.27.0,<0.28.0)
+Requires-Dist: mcp (>=1.6.0,<2.0.0)
+Requires-Dist: pydantic (>=2.11.2,<3.0.0)
+Description-Content-Type: text/markdown
+
+# CodeMie Assistants MCP Server
+
+Python server implementing Model Context Protocol (MCP) for CodeMie Assistants operations.
+
+## Features
+- Chat with AI/Run CodeMie assistant
+
+Note: The server requires authentication credentials via environment variables.
+
+## API
+
+### Tools
+
+#### chat
+Chat with a specific AI assistant
+Inputs:
+- `message (string)`: Message to send to assistant
+- `conversation_id (string)`: Identifier of current conversation. It should be always passed if present in current communication thread.
+- `history (array, optional)`: Previous conversation messages in format:
+  [{"role": "user|assistant", "message": "text"}]
+
+Returns generated assistant response as text
+
+## Installation
+
+Ensure you have `Python 3.12` or later installed.
+
+### Using uv (recommended)
+
+When using [`uv`](https://docs.astral.sh/uv/) no specific installation is needed. We will
+use [`uvx`](https://docs.astral.sh/uv/guides/tools/) to directly run *codemie-mcp-assistants*.
+
+```bash
+uvx codemie-mcp-assistants
+```
+
+### Using Poetry
+
+Alternatively you can install via Poetry:
+
+```bash
+poetry install codemie-mcp-assistants
+```
+
+After installation, you can run it as a script using:
+
+```bash
+poetry run codemie-mcp-assistants
+```
+
+## Configuration
+
+### Configure for Claude.app
+
+Add to your Claude settings:
+
+<details>
+<summary>Using uvx</summary>
+
+```json
+"mcpServers": {
+  "codemie": {
+    "command": "uvx",
+    "args": ["codemie-mcp-assistants"],
+    "env": {
+      "CODEMIE_ASSISTANT_ID": "your-assistant-id"
+      "CODEMIE_USERNAME": "your-username",
+      "CODEMIE_PASSWORD": "your-password"
+    }
+  }
+}
+```
+</details>
+
+<details>
+<summary>Using poetry installation</summary>
+
+```json
+"mcpServers": {
+  "codemie": {
+    "command": "poetry",
+    "args": ["run", "codemie-mcp-assistants"],
+    "env": {
+      "CODEMIE_ASSISTANT_ID": "your-assistant-id"
+      "CODEMIE_USERNAME": "your-username",
+      "CODEMIE_PASSWORD": "your-password"
+    }
+  }
+}
+```
+</details>
+
+### Environment Variables
+
+- `CODEMIE_ASSISTANT_ID`: "AI/Run CodeMie assistant UID"
+
+The following environment variables are required for authentication:
+
+- `CODEMIE_USERNAME`: Your CodeMie username
+- `CODEMIE_PASSWORD`: Your CodeMie password
+
+Optional configuration:
+- `CODEMIE_AUTH_CLIENT_ID`: Auth client ID (default: "codemie-sdk")
+- `CODEMIE_AUTH_REALM_NAME`: Auth realm name (default: "codemie-prod")
+
+## Build
+
+### Make build:
+```bash
+make build
+```
+

codemie_mcp_assistants-0.1.5/README.md

@@ -0,0 +1,111 @@
+# CodeMie Assistants MCP Server
+
+Python server implementing Model Context Protocol (MCP) for CodeMie Assistants operations.
+
+## Features
+- Chat with AI/Run CodeMie assistant
+
+Note: The server requires authentication credentials via environment variables.
+
+## API
+
+### Tools
+
+#### chat
+Chat with a specific AI assistant
+Inputs:
+- `message (string)`: Message to send to assistant
+- `conversation_id (string)`: Identifier of current conversation. It should be always passed if present in current communication thread.
+- `history (array, optional)`: Previous conversation messages in format:
+  [{"role": "user|assistant", "message": "text"}]
+
+Returns generated assistant response as text
+
+## Installation
+
+Ensure you have `Python 3.12` or later installed.
+
+### Using uv (recommended)
+
+When using [`uv`](https://docs.astral.sh/uv/) no specific installation is needed. We will
+use [`uvx`](https://docs.astral.sh/uv/guides/tools/) to directly run *codemie-mcp-assistants*.
+
+```bash
+uvx codemie-mcp-assistants
+```
+
+### Using Poetry
+
+Alternatively you can install via Poetry:
+
+```bash
+poetry install codemie-mcp-assistants
+```
+
+After installation, you can run it as a script using:
+
+```bash
+poetry run codemie-mcp-assistants
+```
+
+## Configuration
+
+### Configure for Claude.app
+
+Add to your Claude settings:
+
+<details>
+<summary>Using uvx</summary>
+
+```json
+"mcpServers": {
+  "codemie": {
+    "command": "uvx",
+    "args": ["codemie-mcp-assistants"],
+    "env": {
+      "CODEMIE_ASSISTANT_ID": "your-assistant-id"
+      "CODEMIE_USERNAME": "your-username",
+      "CODEMIE_PASSWORD": "your-password"
+    }
+  }
+}
+```
+</details>
+
+<details>
+<summary>Using poetry installation</summary>
+
+```json
+"mcpServers": {
+  "codemie": {
+    "command": "poetry",
+    "args": ["run", "codemie-mcp-assistants"],
+    "env": {
+      "CODEMIE_ASSISTANT_ID": "your-assistant-id"
+      "CODEMIE_USERNAME": "your-username",
+      "CODEMIE_PASSWORD": "your-password"
+    }
+  }
+}
+```
+</details>
+
+### Environment Variables
+
+- `CODEMIE_ASSISTANT_ID`: "AI/Run CodeMie assistant UID"
+
+The following environment variables are required for authentication:
+
+- `CODEMIE_USERNAME`: Your CodeMie username
+- `CODEMIE_PASSWORD`: Your CodeMie password
+
+Optional configuration:
+- `CODEMIE_AUTH_CLIENT_ID`: Auth client ID (default: "codemie-sdk")
+- `CODEMIE_AUTH_REALM_NAME`: Auth realm name (default: "codemie-prod")
+
+## Build
+
+### Make build:
+```bash
+make build
+```

{codemie_mcp_assistants-0.1.4 → codemie_mcp_assistants-0.1.5}/pyproject.toml

@@ -2,38 +2,41 @@
 name = "codemie-mcp-assistants"
 version = "0.1.2"
 description = "MCP server for connecting to CodeMie Assistants API"
-#readme = "README.md"
+readme = "README.md"
 packages = [
-    { include = "assistants_mcp", from = "src" }
+    { include = "src"}
 ]
 
 [tool.poetry]
 name = "codemie-mcp-assistants"
-version = "0.1.4"
+version = "0.1.5"
 description = "MCP server for connecting to CodeMie Assistants API"
 authors = [
+    "Vadym Vlasenko <vadym_vlasenko@epam.com>",
     "Nikita Levyankov <nikita_levyankov@epam.com>",
 ]
-#readme = "README.md"
+readme = "README.md"
 packages = [
-    { include = "assistants_mcp", from = "src" }
+    { include = "src"}
 ]
 
 [tool.poetry.dependencies]
 python = "^3.12"
-mcp = "^1.2.0"
+mcp = "^1.6.0"
 httpx = "^0.27.0"
-codemie-sdk-python = "0.1.4"
+codemie-sdk-python = "0.1.5"
 certifi = "^2025.1.31"
+pydantic = "^2.11.2"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.0.0"
 black = "^24.1.0"
 isort = "^5.13.2"
+ruff = "^0.11.3"
 
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.scripts]
-codemie-mcp-assistant = "src.assistants_mcp:main"
+codemie-mcp-assistants = "src.assistants_mcp:main"

codemie_mcp_assistants-0.1.5/src/model.py

@@ -0,0 +1,114 @@
+import os
+from typing import Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class AssistantInfo(BaseModel):
+    """Model representing assistant information from the MCP API"""
+
+    id: str = Field(..., description="Unique identifier of the assistant")
+    name: str = Field(..., description="Name of the assistant")
+    slug: Optional[str] = Field(None, description="Slug of the assistant")
+    description: str = Field(..., description="Description of the assistant")
+    project: Optional[str] = Field(None, description="Associated project name")
+
+
+class AssistantNotFoundError(Exception):
+    """Exception raised when an assistant is not found"""
+
+    def __init__(self, assistant_id: str):
+        self.assistant_id = assistant_id
+        self.message = f"Assistant with ID {assistant_id} not found"
+        super().__init__(self.message)
+
+
+class AuthConfig(BaseModel):
+    """Authentication configuration with support for multiple auth methods."""
+
+    username: Optional[str] = Field(
+        default=None, description="Username for password-based authentication"
+    )
+    password: Optional[str] = Field(
+        default=None, description="Password for password-based authentication"
+    )
+    client_id: str = Field(
+        default="codemie-sdk",
+        description="Client ID for client credentials authentication",
+    )
+    client_secret: Optional[str] = Field(
+        default=None, description="Client secret for client credentials authentication"
+    )
+
+    @model_validator(mode="after")
+    def validate_auth_method(self) -> "AuthConfig":
+        has_user_pass = bool(self.username and self.password)
+        has_client_creds = bool(self.client_id and self.client_secret)
+
+        if not (has_user_pass or has_client_creds):
+            raise ValueError(
+                "Authentication configuration missing. Please provide either:\n"
+                "- CODEMIE_USERNAME and CODEMIE_PASSWORD for password authentication\n"
+                "- CODEMIE_AUTH_CLIENT_ID and CODEMIE_AUTH_CLIENT_SECRET for client credentials\n"
+            )
+
+        if has_user_pass and has_client_creds:
+            import warnings
+
+            warnings.warn(
+                "Both authentication methods provided. Using client credentials authentication.",
+                UserWarning,
+            )
+
+        return self
+
+
+class Settings:
+    """Application settings configured via environment variables."""
+
+    # Default values
+    DEFAULT_AUTH_CLIENT_ID = "codemie-sdk"
+    DEFAULT_AUTH_REALM_NAME = "codemie-prod"
+    DEFAULT_AUTH_SERVER_URL = (
+        "https://keycloak.eks-core.aws.main.edp.projects.epam.com/auth"
+    )
+    DEFAULT_CODEMIE_API_DOMAIN = "https://codemie.lab.epam.com/code-assistant-api"
+
+    def __init__(self):
+        # Authentication settings
+        self.auth = AuthConfig(
+            username=os.environ.get("CODEMIE_USERNAME"),
+            password=os.environ.get("CODEMIE_PASSWORD"),
+            client_id=os.environ.get(
+                "CODEMIE_AUTH_CLIENT_ID", self.DEFAULT_AUTH_CLIENT_ID
+            ),
+            client_secret=os.environ.get("CODEMIE_AUTH_CLIENT_SECRET"),
+        )
+
+        # Server configuration
+        self.auth_client_id = os.environ.get(
+            "CODEMIE_AUTH_CLIENT_ID", self.DEFAULT_AUTH_CLIENT_ID
+        )
+        self.auth_realm_name = os.environ.get(
+            "CODEMIE_AUTH_REALM_NAME", self.DEFAULT_AUTH_REALM_NAME
+        )
+        self.auth_server_url = os.environ.get(
+            "CODEMIE_AUTH_SERVER_URL", self.DEFAULT_AUTH_SERVER_URL
+        )
+        self.api_domain = os.environ.get(
+            "CODEMIE_API_DOMAIN", self.DEFAULT_CODEMIE_API_DOMAIN
+        )
+        self.assistant_id = os.environ.get("CODEMIE_ASSISTANT_ID")
+        self.verify_ssl = os.environ.get("CODEMIE_VERIFY_SSL", "true").lower() == "true"
+
+    def __str__(self):
+        """String representation of the settings (excluding sensitive data)."""
+        return (
+            f"Settings:\n"
+            f"  Auth Client ID: {self.auth_client_id}\n"
+            f"  Auth Realm Name: {self.auth_realm_name}\n"
+            f"  Auth Server URL: {self.auth_server_url}\n"
+            f"  API Domain: {self.api_domain}\n"
+            f"  Assistant ID: {self.assistant_id}\n"
+            f"  Verify SSL: {self.verify_ssl}\n"
+        )

codemie_mcp_assistants-0.1.5/src/server.py

@@ -0,0 +1,195 @@
+import sys
+import uuid
+from typing import Dict, List
+
+from codemie_sdk import CodeMieClient
+from codemie_sdk.models.assistant import (
+    AssistantChatRequest,
+    ChatMessage,
+    ChatRole,
+)
+from model import AssistantInfo, AssistantNotFoundError, Settings
+
+from mcp.server.fastmcp import FastMCP
+
+# Initialize settings at module level
+try:
+    settings = Settings()
+except Exception as e:
+    print(f"Error initializing settings: {str(e)}", file=sys.stderr)
+    sys.exit(1)
+
+
+def get_client() -> CodeMieClient:
+    """Gets authenticated CodeMie client instance."""
+    try:
+        client = CodeMieClient(
+            username=settings.auth.username,
+            password=settings.auth.password,
+            auth_client_id=settings.auth.client_id,
+            auth_client_secret=settings.auth.client_secret,
+            verify_ssl=settings.verify_ssl,
+            auth_realm_name=settings.auth_realm_name,
+            auth_server_url=settings.auth_server_url,
+            codemie_api_domain=settings.api_domain,
+        )
+
+        if not client.token:
+            print("Failed to obtain authentication token", file=sys.stderr)
+            raise ValueError("Failed to obtain authentication token")
+
+        print("Successfully initialized CodeMie client", file=sys.stdout)
+        return client
+    except Exception as e:
+        print(f"Error initializing client: {str(e)}", file=sys.stderr)
+        raise
+
+
+def get_assistant_info(assistant_id: str) -> AssistantInfo:
+    """
+    Retrieve and validate assistant information.
+
+    Args:
+        assistant_id: The ID of the assistant to retrieve
+
+    Returns:
+        AssistantInfo: Validated assistant information
+
+    Raises:
+        AssistantNotFoundError: If the assistant doesn't exist
+        ValueError: If there are validation errors
+    """
+    try:
+        assistant = get_client().assistants.get(assistant_id)
+        if not assistant:
+            raise AssistantNotFoundError(assistant_id)
+
+        return AssistantInfo(
+            id=assistant.id,
+            name=assistant.name,
+            description=assistant.description,
+            project=assistant.project,
+            slug=assistant.slug,
+        )
+    except AssistantNotFoundError:
+        print(f"Assistant not found: {assistant_id}", file=sys.stderr)
+        raise
+    except Exception as e:
+        print(f"Error retrieving assistant {assistant_id}: {str(e)}", file=sys.stderr)
+        raise
+
+
+# Initialize FastMCP server
+mcp = FastMCP("codemie-assistants")
+# Get and validate assistant by identifier.
+codemie_assistant = get_assistant_info(settings.assistant_id)
+
+chat_tool_name = "ask_" + codemie_assistant.name.lower().replace(" ", "_")
+chat_assistant_tool_description = (
+    f"""
+This tool allows to ask and communicate with '{codemie_assistant.name}'.
+Call this tool when '{codemie_assistant.slug}' or '{codemie_assistant.name} is present in message'
+Purpose of '{codemie_assistant.name}' is: {codemie_assistant.description}.
+You MUST always call this tool when '{codemie_assistant.name}' is tagged or referenced.
+"""
+    + """
+Tool accepts the following parameters:
+ - message - required. User message to send to assistant
+ - conversation_id - string. Identifier of current conversation. if context or history contains Conversation_Id, this ID must be passed as parameter
+ must not be passed with the first call, only if returned previously
+ - history. List[Dict[str, str]]. MUST always be passed to assistant
+    Example of the given param [{"role": "User", "message": "show my tools"}, {"role": "Assistant", "message": "Here are the tools available for use: **functions.generic_jira_tool**}]
+    This parameter must always be filled when conversation is in progress
+
+Returns assistant response. IMPORTANT: response must never be formatter or summarized. 
+"""
+)
+
+
+@mcp.tool(
+    name=chat_tool_name,
+    description=chat_assistant_tool_description,
+)
+async def chat_with_assistant(
+    message: str,
+    history: List[Dict[str, str]] = None,
+    conversation_id: str = None,
+) -> str:
+    """
+    Chat with a specific assistant.
+    :param str message: required. User request to send to assistant
+    :param List[Dict[str, str]] history: Must be passed to assistant if user proceeds current conversation
+    :param str conversation_id: Identifier of current conversation
+    Example of the given param [{'role': 'User', 'message': 'show my tools'}, {'role': 'Assistant', 'message': 'Here are the tools available for use: **functions.generic_jira_tool**'}]
+    This parameter must always be filled when conversation is in progress
+
+    :return response from assistant.
+    """
+    try:
+        client = get_client()
+        if not message or not message.strip():
+            print("Empty message provided", file=sys.stderr)
+            raise ValueError("Empty message provided")
+
+        # Convert history to ChatMessage objects if provided
+        chat_history = []
+        if history:
+            try:
+                for msg in history:
+                    if (
+                        not isinstance(msg, dict)
+                        or "role" not in msg
+                        or "message" not in msg
+                    ):
+                        print(f"Invalid history format: {msg}", file=sys.stderr)
+                        raise ValueError(f"Invalid history format: {msg}")
+                    chat_history.append(
+                        ChatMessage(role=ChatRole(msg["role"]), message=msg["message"])
+                    )
+            except Exception as e:
+                print(f"Error processing chat history: {str(e)}", file=sys.stderr)
+                raise
+
+        # Create chat request
+        if not conversation_id:
+            conversation_id = str(uuid.uuid4())
+        print(f"Starting chat with assistant {settings.assistant_id} ", file=sys.stdout)
+
+        request = AssistantChatRequest(
+            text=message,
+            conversation_id=conversation_id,
+            history=chat_history,
+            stream=False,
+        )
+
+        # Send chat request
+        response = client.assistants.chat(
+            assistant_id=settings.assistant_id, request=request
+        )
+
+        if not response or not response.generated:
+            print(
+                f"Received empty response from {codemie_assistant.name}",
+                file=sys.stderr,
+            )
+            raise ValueError("Received empty response from assistant")
+
+        print(
+            f"Successfully received response from {codemie_assistant.name} for conversation {conversation_id}",
+            file=sys.stdout,
+        )
+        return f"Response: {response.generated}. Conversation_Id: {conversation_id}"
+
+    except Exception as e:
+        print(f"Error in chat_with_assistant: {str(e)}", file=sys.stderr)
+        raise
+
+
+if __name__ == "__main__":
+    try:
+        print("Starting CodeMie Assistants MCP server", file=sys.stdout)
+        # Initialize and run the server
+        mcp.run(transport="stdio")
+    except Exception as e:
+        print(f"Error starting MCP server: {str(e)}", file=sys.stderr)
+        sys.exit(1)

codemie_mcp_assistants-0.1.4/PKG-INFO

@@ -1,13 +0,0 @@
-Metadata-Version: 2.1
-Name: codemie-mcp-assistants
-Version: 0.1.4
-Summary: MCP server for connecting to CodeMie Assistants API
-Author: Nikita Levyankov
-Author-email: nikita_levyankov@epam.com
-Requires-Python: >=3.12,<4.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: certifi (>=2025.1.31,<2026.0.0)
-Requires-Dist: codemie-sdk-python (==0.1.4)
-Requires-Dist: httpx (>=0.27.0,<0.28.0)
-Requires-Dist: mcp (>=1.2.0,<2.0.0)

codemie_mcp_assistants-0.1.4/src/assistants_mcp/assistants_mcp.py

@@ -1,151 +0,0 @@
-import os
-import uuid
-from typing import Any, Dict, List, Optional
-
-from codemie_sdk import CodeMieClient
-from codemie_sdk.models.assistant import (
-    AssistantChatRequest,
-    ChatMessage,
-    ChatRole,
-)
-from mcp.server.fastmcp import FastMCP
-
-DEFAULT_AUTH_CLIENT_ID = "codemie-sdk"
-DEFAULT_AUTH_REALM_NAME = "codemie-prod"
-DEFAULT_AUTH_SERVER_URL = (
-    "https://keycloak.eks-core.aws.main.edp.projects.epam.com/auth"
-)
-DEFAULT_CODEMIE_API_DOMAIN = "https://codemie.lab.epam.com/code-assistant-api"
-
-# Initialize FastMCP server
-mcp = FastMCP("codemie-assistants")
-
-# Client instance
-_client: Optional[CodeMieClient] = None
-
-
-def get_client() -> CodeMieClient:
-    """Gets authenticated CodeMie client instance."""
-    username = os.getenv("CODEMIE_USERNAME")
-    password = os.getenv("CODEMIE_PASSWORD")
-    auth_client_id = os.getenv("CODEMIE_AUTH_CLIENT_ID", DEFAULT_AUTH_CLIENT_ID)
-    auth_realm_name = os.getenv("CODEMIE_AUTH_REALM_NAME", DEFAULT_AUTH_REALM_NAME)
-    auth_server_url = os.getenv("CODEMIE_AUTH_SERVER_URL", DEFAULT_AUTH_SERVER_URL)
-    codemie_api_domain = os.getenv("CODEMIE_API_DOMAIN", DEFAULT_CODEMIE_API_DOMAIN)
-
-    if not username or not password:
-        raise ValueError(
-            "Username and password must be set via environment variables: CODEMIE_USERNAME, CODEMIE_PASSWORD"
-        )
-
-    return CodeMieClient(
-        username=username,
-        password=password,
-        verify_ssl=False,
-        auth_client_id=auth_client_id,
-        auth_realm_name=auth_realm_name,
-        auth_server_url=auth_server_url,
-        codemie_api_domain=codemie_api_domain,
-    )
-
-
-@mcp.tool()
-async def get_tools() -> List[Dict[str, Any]]:
-    """Get available tools for assistants."""
-    try:
-        print("Getting tools")
-        client = get_client()
-        if client.token is None:
-            raise ValueError("Client not initialized")
-        toolkits = client.assistants.get_tools()
-
-        # Convert to dict format for better visualization
-        tools_list = []
-        for toolkit in toolkits:
-            tools_list.extend(
-                [
-                    {
-                        "toolkit": toolkit.toolkit,
-                        "tool": tool.name,
-                        "label": tool.label or tool.name,
-                        "settings_required": tool.settings_config,
-                    }
-                    for tool in toolkit.tools
-                ]
-            )
-
-        return tools_list
-    except Exception as e:
-        print(f"Error getting tools: {str(e)}")
-        raise e
-
-
-@mcp.tool()
-async def get_assistants(
-    minimal: bool = True, project: Optional[str] = None
-) -> List[Dict[str, Any]]:
-    """Get list of available assistants.
-
-    Args:
-        minimal: Return minimal info (default: True)
-        project: Filter by project name
-    """
-    client = get_client()
-    filters = {"project": project} if project else None
-
-    assistants = client.assistants.list(minimal_response=minimal, filters=filters)
-
-    # Convert to dict format
-    return [
-        {
-            "id": asst.id,
-            "name": asst.name,
-            "description": asst.description,
-            "project": getattr(asst, "project", None) if not minimal else None,
-        }
-        for asst in assistants
-    ]
-
-
-@mcp.tool()
-async def chat_with_assistant(
-    message: str,
-    assistant_id: str,
-    conversation_id: Optional[str] = None,
-    history: Optional[List[Dict[str, str]]] = None,
-) -> str:
-    """Chat with a specific assistant.
-
-    Args:
-        message: User message
-        assistant_id: ID of the assistant to chat with
-        conversation_id: Optional conversation ID
-        history: Optional chat history as list of dicts with role and message
-    """
-    client = get_client()
-
-    # Convert history to ChatMessage objects if provided
-    chat_history = []
-    if history:
-        for msg in history:
-            chat_history.append(
-                ChatMessage(role=ChatRole(msg["role"]), message=msg["message"])
-            )
-
-    # Create chat request
-    request = AssistantChatRequest(
-        text=message,
-        conversation_id=conversation_id if conversation_id else str(uuid.uuid4()),
-        history=chat_history,
-        stream=False,  # For now using non-streaming responses
-    )
-
-    # Send chat request
-    response = client.assistants.chat(assistant_id=assistant_id, request=request)
-
-    return response.generated
-
-
-if __name__ == "__main__":
-    # Initialize and run the server
-    mcp.run(transport="stdio")