feat: Add chat completion support for Meilisearch v1.6+

- Implement ChatManager class with chat workspace and completion methods
- Add 6 new MCP tools for chat functionality:
  - chat-completion: Generate responses with RAG using indexed documents
  - create-chat-workspace: Create workspaces with default settings
  - update-chat-workspace: Modify existing workspace configurations
  - list-chat-workspaces: List all available workspaces
  - get-chat-workspace: Get specific workspace details
  - delete-chat-workspace: Remove workspaces
- Add streaming support for chat completions
- Include comprehensive tests for all chat features
- Update README with chat feature documentation and examples

This enables Meilisearch MCP users to leverage the new chat completions
feature introduced in Meilisearch v1.6.0, allowing LLMs to generate
contextual responses using indexed documents as knowledge base.

Author: tpayet

README.md

@@ -110,6 +110,20 @@ AI: Searching across all indices... Found 47 results from 3 indices:
 - 'tutorials': 9 hands-on tutorials
 ```
 
+### 🤖 Chat Completions with RAG (v1.6+):
+
+```
+You: "Create a chat workspace for customer support with my products and FAQs indices"
+AI: I'll create that workspace... ✓ Chat workspace 'support-chat' created!
+
+You: "Using the support workspace, how do I return a defective product?"
+AI: Based on your FAQs and product policies, here's the return process...
+[Generates contextual response using indexed documents]
+
+You: "Generate a response about our warranty policy"
+AI: [Streams response] According to your documentation, the warranty covers...
+```
+
 ## 🔧 Installation
 
 ### Prerequisites
@@ -352,6 +366,14 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 #### Search
 - `search`: Flexible search across single or multiple indices with filtering and sorting options
 
+#### Chat Completions (Meilisearch v1.6+)
+- `chat-completion`: Generate chat responses with RAG using indexed documents as context (supports streaming)
+- `create-chat-workspace`: Create a chat workspace with default settings for consistent interactions
+- `update-chat-workspace`: Modify existing chat workspace configurations
+- `list-chat-workspaces`: List all available chat workspaces
+- `get-chat-workspace`: Get details of a specific chat workspace
+- `delete-chat-workspace`: Remove a chat workspace
+
 #### Settings Management
 - `get-settings`: View current settings for an index
 - `update-settings`: Update index settings (ranking, faceting, etc.)

src/meilisearch_mcp/chat.py

@@ -0,0 +1,278 @@
+from typing import Dict, Any, List, Optional, AsyncIterator
+from meilisearch import Client
+import httpx
+import json
+
+
+class ChatManager:
+    """Manage Meilisearch chat completions and workspaces"""
+
+    def __init__(self, client: Client):
+        self.client = client
+        self.base_url = client.config.url.rstrip("/")
+        self.headers = {
+            "Authorization": (
+                f"Bearer {client.config.api_key}" if client.config.api_key else None
+            ),
+            "Content-Type": "application/json",
+        }
+        # Remove None values from headers
+        self.headers = {k: v for k, v in self.headers.items() if v is not None}
+
+    async def chat_completion_stream(
+        self,
+        query: str,
+        model: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        index_uids: Optional[List[str]] = None,
+        workspace_uid: Optional[str] = None,
+    ) -> AsyncIterator[str]:
+        """
+        Stream chat completion responses from Meilisearch.
+
+        Args:
+            query: The user's query/prompt
+            model: The model to use for chat completion (e.g., "gpt-4", "gpt-3.5-turbo")
+            temperature: Controls randomness (0-1)
+            max_tokens: Maximum tokens in response
+            index_uids: List of index UIDs to search for context
+            workspace_uid: Chat workspace UID to use
+
+        Yields:
+            Streaming response chunks
+        """
+        endpoint = f"{self.base_url}/chat/completions"
+
+        payload = {"query": query, "stream": True}
+
+        if model:
+            payload["model"] = model
+        if temperature is not None:
+            payload["temperature"] = temperature
+        if max_tokens:
+            payload["maxTokens"] = max_tokens
+        if index_uids:
+            payload["indexUids"] = index_uids
+        if workspace_uid:
+            payload["workspaceUid"] = workspace_uid
+
+        async with httpx.AsyncClient() as client:
+            async with client.stream(
+                "POST", endpoint, headers=self.headers, json=payload, timeout=60.0
+            ) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if line.startswith("data: "):
+                        data = line[6:]  # Remove "data: " prefix
+                        if data == "[DONE]":
+                            break
+                        try:
+                            chunk = json.loads(data)
+                            if "choices" in chunk and chunk["choices"]:
+                                content = (
+                                    chunk["choices"][0]
+                                    .get("delta", {})
+                                    .get("content", "")
+                                )
+                                if content:
+                                    yield content
+                        except json.JSONDecodeError:
+                            continue
+
+    def chat_completion(
+        self,
+        query: str,
+        model: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        index_uids: Optional[List[str]] = None,
+        workspace_uid: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Get a non-streaming chat completion response.
+
+        Args:
+            query: The user's query/prompt
+            model: The model to use for chat completion
+            temperature: Controls randomness (0-1)
+            max_tokens: Maximum tokens in response
+            index_uids: List of index UIDs to search for context
+            workspace_uid: Chat workspace UID to use
+
+        Returns:
+            Chat completion response
+        """
+        endpoint = f"{self.base_url}/chat/completions"
+
+        payload = {"query": query, "stream": False}
+
+        if model:
+            payload["model"] = model
+        if temperature is not None:
+            payload["temperature"] = temperature
+        if max_tokens:
+            payload["maxTokens"] = max_tokens
+        if index_uids:
+            payload["indexUids"] = index_uids
+        if workspace_uid:
+            payload["workspaceUid"] = workspace_uid
+
+        with httpx.Client() as client:
+            response = client.post(
+                endpoint, headers=self.headers, json=payload, timeout=60.0
+            )
+            response.raise_for_status()
+            return response.json()
+
+    def create_chat_workspace(
+        self,
+        uid: str,
+        name: str,
+        description: Optional[str] = None,
+        model: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        index_uids: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a new chat workspace.
+
+        Args:
+            uid: Unique identifier for the workspace
+            name: Name of the workspace
+            description: Description of the workspace
+            model: Default model for this workspace
+            temperature: Default temperature for this workspace
+            max_tokens: Default max tokens for this workspace
+            index_uids: Default index UIDs for this workspace
+
+        Returns:
+            Created workspace information
+        """
+        endpoint = f"{self.base_url}/chat/workspaces"
+
+        payload = {"uid": uid, "name": name}
+
+        if description:
+            payload["description"] = description
+        if model:
+            payload["model"] = model
+        if temperature is not None:
+            payload["temperature"] = temperature
+        if max_tokens:
+            payload["maxTokens"] = max_tokens
+        if index_uids:
+            payload["indexUids"] = index_uids
+
+        with httpx.Client() as client:
+            response = client.post(endpoint, headers=self.headers, json=payload)
+            response.raise_for_status()
+            return response.json()
+
+    def update_chat_workspace(
+        self,
+        uid: str,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        model: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        index_uids: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Update an existing chat workspace.
+
+        Args:
+            uid: Unique identifier of the workspace to update
+            name: New name for the workspace
+            description: New description for the workspace
+            model: New default model for this workspace
+            temperature: New default temperature for this workspace
+            max_tokens: New default max tokens for this workspace
+            index_uids: New default index UIDs for this workspace
+
+        Returns:
+            Updated workspace information
+        """
+        endpoint = f"{self.base_url}/chat/workspaces/{uid}"
+
+        payload = {}
+
+        if name:
+            payload["name"] = name
+        if description:
+            payload["description"] = description
+        if model:
+            payload["model"] = model
+        if temperature is not None:
+            payload["temperature"] = temperature
+        if max_tokens:
+            payload["maxTokens"] = max_tokens
+        if index_uids:
+            payload["indexUids"] = index_uids
+
+        with httpx.Client() as client:
+            response = client.patch(endpoint, headers=self.headers, json=payload)
+            response.raise_for_status()
+            return response.json()
+
+    def list_chat_workspaces(
+        self, limit: Optional[int] = None, offset: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        List all chat workspaces.
+
+        Args:
+            limit: Maximum number of workspaces to return
+            offset: Number of workspaces to skip
+
+        Returns:
+            List of chat workspaces
+        """
+        endpoint = f"{self.base_url}/chat/workspaces"
+
+        params = {}
+        if limit:
+            params["limit"] = limit
+        if offset:
+            params["offset"] = offset
+
+        with httpx.Client() as client:
+            response = client.get(endpoint, headers=self.headers, params=params)
+            response.raise_for_status()
+            return response.json()
+
+    def get_chat_workspace(self, uid: str) -> Dict[str, Any]:
+        """
+        Get details of a specific chat workspace.
+
+        Args:
+            uid: Unique identifier of the workspace
+
+        Returns:
+            Workspace details
+        """
+        endpoint = f"{self.base_url}/chat/workspaces/{uid}"
+
+        with httpx.Client() as client:
+            response = client.get(endpoint, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+
+    def delete_chat_workspace(self, uid: str) -> Dict[str, Any]:
+        """
+        Delete a chat workspace.
+
+        Args:
+            uid: Unique identifier of the workspace to delete
+
+        Returns:
+            Deletion confirmation
+        """
+        endpoint = f"{self.base_url}/chat/workspaces/{uid}"
+
+        with httpx.Client() as client:
+            response = client.delete(endpoint, headers=self.headers)
+            response.raise_for_status()
+            return response.json()

src/meilisearch_mcp/client.py

@@ -9,6 +9,7 @@
 from .keys import KeyManager
 from .logging import MCPLogger
 from .monitoring import MonitoringManager
+from .chat import ChatManager
 from .__version__ import __version__
 
 logger = MCPLogger()
@@ -31,6 +32,7 @@ def __init__(
         self.tasks = TaskManager(self.client)
         self.keys = KeyManager(self.client)
         self.monitoring = MonitoringManager(self.client)
+        self.chat = ChatManager(self.client)
 
     def health_check(self) -> bool:
         """Check if Meilisearch is healthy"""