Add documentation for Meilisearch chat feature

This PR documents the new experimental chat feature that enables AI-powered conversational search.

Changes include:
- Conceptual overview in learn/ai_powered_search/conversational_search_with_chat.mdx
- Complete API reference in reference/api/chats.mdx
- Implementation guide in guides/ai/getting_started_with_chat.mdx
- Updated experimental features documentation to include chat
- Added navigation entries in docs.json

The documentation follows Meilisearch's style guidelines and is organized according to the existing structure:
- Learn section for concepts
- Reference section for API details
- Guides section for practical implementation

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: tpayet

docs.json

@@ -165,6 +165,7 @@
                 "group": "AI-powered search",
                 "pages": [
                   "learn/ai_powered_search/getting_started_with_ai_search",
+                  "learn/ai_powered_search/conversational_search_with_chat",
                   "learn/ai_powered_search/configure_rest_embedder",
                   "learn/ai_powered_search/document_template_best_practices",
                   "learn/ai_powered_search/image_search_with_user_provided_embeddings",
@@ -329,6 +330,7 @@
                   "reference/api/network",
                   "reference/api/similar",
                   "reference/api/facet_search",
+                  "reference/api/chats",
                   "reference/api/tasks",
                   "reference/api/batches",
                   "reference/api/keys",
@@ -419,6 +421,13 @@
                   "guides/vercel"
                 ]
               },
+              {
+                "group": "AI",
+                "pages": [
+                  "guides/ai/getting_started_with_chat",
+                  "guides/ai/mcp"
+                ]
+              },
               {
                 "group": "Miscellaneous",
                 "pages": [

guides/ai/getting_started_with_chat.mdx

@@ -0,0 +1,359 @@
+---
+title: Getting started with conversational search
+sidebarTitle: Getting started with chat
+description: Learn how to implement AI-powered conversational search in your application
+---
+
+import { Warning, Note } from '/snippets/notice_tag.mdx'
+
+This guide walks you through implementing Meilisearch's chat feature to create conversational search experiences in your application.
+
+<Warning>
+The chat feature is experimental and must be enabled before use. See [experimental features](/reference/api/experimental_features) for activation instructions.
+</Warning>
+
+## Prerequisites
+
+Before starting, ensure you have:
+- Meilisearch instance running (v1.11 or later)
+- An API key from an LLM provider (OpenAI or Mistral)
+- At least one index with searchable content
+- The chat experimental feature enabled
+
+## Quick start
+
+### 1. Enable the chat feature
+
+First, enable the chat experimental feature:
+
+```bash
+curl \
+  -X PATCH 'http://localhost:7700/experimental-features' \
+  -H 'Authorization: Bearer MASTER_KEY' \
+  -H 'Content-Type: application/json' \
+  --data-binary '{
+    "chat": true
+  }'
+```
+
+### 2. Configure a chat workspace
+
+Create a workspace with your LLM provider settings:
+
+```bash
+curl \
+  -X PUT 'http://localhost:7700/chats/my-assistant/settings' \
+  -H 'Authorization: Bearer MASTER_KEY' \
+  -H 'Content-Type: application/json' \
+  --data-binary '{
+    "provider": "openai",
+    "model": "gpt-3.5-turbo",
+    "apiKey": "sk-...",
+    "prompt": "You are a helpful assistant. Answer questions based only on the provided context."
+  }'
+```
+
+### 3. Send your first chat request
+
+Now you can start a conversation:
+
+```bash
+curl \
+  -X POST 'http://localhost:7700/chats/my-assistant/chat/completions' \
+  -H 'Authorization: Bearer DEFAULT_CHAT_KEY' \
+  -H 'Content-Type: application/json' \
+  --data-binary '{
+    "model": "gpt-3.5-turbo",
+    "messages": [
+      {
+        "role": "user",
+        "content": "What is Meilisearch?"
+      }
+    ],
+    "stream": true
+  }'
+```
+
+## Understanding workspaces
+
+Workspaces allow you to create isolated chat configurations for different use cases:
+
+- **Customer support**: Configure with support-focused prompts
+- **Product search**: Optimize for e-commerce queries
+- **Documentation**: Tune for technical Q&A
+
+Each workspace maintains its own:
+- LLM provider configuration
+- System prompt
+- Access permissions
+
+## Building a chat interface
+
+Here's a simple example using JavaScript to create an interactive chat:
+
+```javascript
+async function sendMessage(message) {
+  const response = await fetch('http://localhost:7700/chats/my-assistant/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Authorization': 'Bearer YOUR_API_KEY',
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      model: 'gpt-3.5-turbo',
+      messages: [
+        {
+          role: 'user',
+          content: message
+        }
+      ],
+      stream: true
+    })
+  });
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let assistantResponse = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    
+    const chunk = decoder.decode(value);
+    const lines = chunk.split('\n');
+    
+    for (const line of lines) {
+      if (line.startsWith('data: ') && line !== 'data: [DONE]') {
+        try {
+          const data = JSON.parse(line.slice(6));
+          const content = data.choices[0]?.delta?.content || '';
+          assistantResponse += content;
+          // Update your UI here
+        } catch (e) {
+          // Handle parsing errors
+        }
+      }
+    }
+  }
+  
+  return assistantResponse;
+}
+```
+
+## Managing conversations
+
+Since the chat API is stateless, you need to maintain conversation history client-side:
+
+```javascript
+class ChatConversation {
+  constructor() {
+    this.messages = [];
+  }
+
+  async sendMessage(content) {
+    // Add user message to history
+    this.messages.push({ role: 'user', content });
+
+    // Send entire conversation
+    const response = await fetch('http://localhost:7700/chats/my-assistant/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': 'Bearer YOUR_API_KEY',
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        model: 'gpt-3.5-turbo',
+        messages: this.messages,
+        stream: true
+      })
+    });
+
+    // Process streaming response
+    const assistantMessage = await this.processStream(response);
+    
+    // Add assistant response to history
+    this.messages.push({ role: 'assistant', content: assistantMessage });
+    
+    return assistantMessage;
+  }
+
+  async processStream(response) {
+    // Stream processing logic here (see previous example)
+  }
+}
+```
+
+## Best practices
+
+### 1. Craft effective system prompts
+
+Your system prompt shapes how the assistant responds:
+
+```javascript
+const prompts = {
+  customerSupport: `You are a helpful customer support assistant. 
+    Answer questions based only on the provided product documentation. 
+    If you don't know the answer, say so politely and suggest contacting support.`,
+  
+  technicalDocs: `You are a technical documentation assistant. 
+    Provide accurate, concise answers with code examples when relevant. 
+    Always cite the source document.`,
+  
+  ecommerce: `You are a shopping assistant. 
+    Help users find products based on their needs. 
+    Mention key features and benefits.`
+};
+```
+
+### 2. Handle streaming responses properly
+
+Always implement proper error handling for streaming:
+
+```javascript
+async function processStreamWithErrorHandling(response) {
+  if (!response.ok) {
+    throw new Error(`HTTP error! status: ${response.status}`);
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      
+      // Process chunks
+    }
+  } catch (error) {
+    console.error('Streaming error:', error);
+    reader.releaseLock();
+    throw error;
+  }
+}
+```
+
+### 3. Implement conversation limits
+
+Manage token usage by limiting conversation length:
+
+```javascript
+function trimConversation(messages, maxMessages = 10) {
+  if (messages.length <= maxMessages) return messages;
+  
+  // Keep system message if present
+  const systemMessage = messages.find(m => m.role === 'system');
+  const recentMessages = messages.slice(-maxMessages);
+  
+  return systemMessage 
+    ? [systemMessage, ...recentMessages.filter(m => m.role !== 'system')]
+    : recentMessages;
+}
+```
+
+## Security considerations
+
+### API key management
+
+<Note>
+Never expose your master key or LLM API keys in client-side code. Use server-side proxies or secure key management.
+</Note>
+
+Recommended approach:
+
+1. Store LLM API keys server-side
+2. Create workspace configurations using your master key
+3. Use restricted API keys or tenant tokens for client access
+
+### Multi-tenant applications
+
+For multi-tenant scenarios, use tenant tokens:
+
+```javascript
+// Server-side: Generate tenant token
+const searchRules = {
+  'products': { 'filter': 'tenant_id = 123' }
+};
+
+const tenantToken = await generateTenantToken(
+  apiKeyUid,
+  searchRules,
+  { apiKey: signingKey }
+);
+
+// Client-side: Use tenant token
+const response = await fetch('http://localhost:7700/chats/support/chat/completions', {
+  headers: {
+    'Authorization': `Bearer ${tenantToken}`
+  },
+  // ... rest of the request
+});
+```
+
+## Common use cases
+
+### Customer support chatbot
+
+```javascript
+const supportConfig = {
+  provider: 'openai',
+  model: 'gpt-3.5-turbo',
+  prompt: `You are a customer support assistant for ACME Corp. 
+    Use the knowledge base to answer customer questions. 
+    Be polite, helpful, and concise. 
+    If you cannot find an answer, offer to escalate to human support.`
+};
+```
+
+### Documentation assistant
+
+```javascript
+const docsConfig = {
+  provider: 'openai',
+  model: 'gpt-4',
+  prompt: `You are a technical documentation assistant. 
+    Provide clear, accurate answers with code examples. 
+    Always mention the source section of the documentation. 
+    If multiple interpretations exist, clarify the context.`
+};
+```
+
+### E-commerce product finder
+
+```javascript
+const commerceConfig = {
+  provider: 'openai',
+  model: 'gpt-3.5-turbo',
+  prompt: `You are a shopping assistant. 
+    Help users find products based on their needs and preferences. 
+    Focus on benefits and use cases. 
+    Suggest alternatives when exact matches aren't available.`
+};
+```
+
+## Troubleshooting
+
+### Common issues
+
+1. **"Feature not enabled" error**
+   - Ensure experimental features are activated
+   - Restart Meilisearch after enabling
+
+2. **"Unauthorized" errors**
+   - Verify API key has chat permissions
+   - Check workspace exists and is properly configured
+
+3. **Streaming interruptions**
+   - Implement reconnection logic
+   - Handle network timeouts gracefully
+
+4. **Empty responses**
+   - Verify indexes contain searchable content
+   - Check API key has access to relevant indexes
+   - Review system prompt for conflicts
+
+## Next steps
+
+- Explore [advanced chat API features](/reference/api/chats)
+- Learn about [conversational search concepts](/learn/ai_powered_search/conversational_search_with_chat)
+- Review [security best practices](/learn/security/basic_security)