+
+ )
+}
+```
+
+
+ {messages.map((message) => (
+
+
+
+
+
+ ))}
+ {message.content}
+
+ {/* Customer List Sidebar */}
+
+ )
+}
+```
+
+## Testing Your Support System
+
+### Step 4: Test Support Scenarios
+
+1. **Test Customer Tiers**:
+ - Free tier: Basic responses, self-service guidance
+ - Pro tier: Detailed help, proactive suggestions
+ - Enterprise: White-glove service, escalation readiness
+
+2. **Test Memory & Context**:
+ - Ask about a previous issue
+ - Reference customer preferences
+ - Follow up on unresolved tickets
+
+3. **Test Escalation Triggers**:
+ - Use keywords like "angry", "manager", "refund"
+ - Test enterprise customer automatic escalation
+
+This comprehensive customer support recipe provides the foundation for building intelligent, context-aware support systems that improve customer satisfaction through personalized service.
+
+---
+
+*Customize this recipe based on your specific support workflows and customer needs.*
\ No newline at end of file
diff --git a/apps/docs/cookbook/document-qa.mdx b/apps/docs/cookbook/document-qa.mdx
new file mode 100644
index 00000000..c3bc224e
--- /dev/null
+++ b/apps/docs/cookbook/document-qa.mdx
@@ -0,0 +1,883 @@
+---
+title: "Document Q&A System"
+description: "Build a chatbot that answers questions from your documents with citations and source references"
+---
+
+Create a powerful document Q&A system that can ingest PDFs, text files, and web pages, then answer questions with accurate citations. Perfect for documentation sites, research databases, or internal knowledge bases.
+
+## What You'll Build
+
+A document Q&A system that:
+- **Ingests multiple file types** (PDFs, DOCX, text, URLs)
+- **Answers questions accurately** with source citations
+- **Provides source references** with page numbers and document titles
+- **Handles follow-up questions** with conversation context
+- **Supports multiple document collections** for different topics
+
+## Prerequisites
+
+- Node.js 18+ or Python 3.8+
+- Supermemory API key
+- OpenAI API key
+- Basic understanding of file handling
+
+## Implementation
+
+### Step 1: Document Processing System
+
+
+
+
+ {/* Main Content */}
+
+
+ Customers
+
+ {mockCustomers.map((customer) => (
+
+ handleCustomerSelect(customer)}
+ className={`p-4 cursor-pointer hover:bg-gray-50 ${
+ selectedCustomer?.id === customer.id ? 'bg-blue-50 border-r-2 border-blue-500' : ''
+ }`}
+ >
+
+ ))}
+
+
+ {customer.name}
+
+ {customer.tier}
+
+ {customer.email}
+
+ Member since {customer.joinDate}
+
+
+ {selectedCustomer ? (
+ <>
+ {/* Customer Header */}
+
+
+
+
+
+
+
+
+ {selectedCustomer.name}
+{selectedCustomer.email}
+
+
+ {selectedCustomer.tier.toUpperCase()} Customer
+
+ {showEscalation && (
+
+
+ Needs Escalation
+
+ )}
+
+ {/* Chat Area */}
+
+
+ ) : (
+
+ {/* Messages */}
+
+
+ {/* Customer History Sidebar */}
+
+ {messages.length === 0 && (
+
+
+ {/* Chat Input */}
+
+
+ )}
+
+ {messages.map((message) => (
+ Welcome to Support Chat
+ + Start a conversation with {selectedCustomer.name} +
+
+
+ Customer Tier: {selectedCustomer.tier}
+Join Date: {selectedCustomer.joinDate}
+
+
+ ))}
+
+ {isLoading && (
+
+
+
+
+ {message.role === 'user' ? selectedCustomer.name : 'Support Agent'}
+
+
+ {new Date().toLocaleTimeString()}
+
+
+ {message.content}
+
+
+ )}
+
+
+
+
+ Agent is typing...
+
+
+
+
+
+
+
+
+ Customer History
+
+ {customerHistory.map((interaction, index) => (
+
+
+
+ ))}
+
+ {customerHistory.length === 0 && (
+
+ {interaction.type}
+
+ {new Date(interaction.timestamp).toLocaleDateString()}
+
+
+ + {interaction.content.length > 100 + ? `${interaction.content.substring(0, 100)}...` + : interaction.content + } +
+ {interaction.outcome && ( +
+
+ {interaction.outcome}
+
+
+ )}
+
+
+ )}
+ No previous interactions
+
+
+ )}
+
+
+ Customer Support
+ Select a customer to start a support conversation
+
+
+ )
+ }
+
+ return (
+ Sources:
+
+ {sources.map((source) => (
+
+
+
+ Document {source.citationNumber}
+
+ {source.title}
+
+ ({source.relevantChunks} relevant chunks, {(source.score * 100).toFixed(1)}% match)
+
+
+ ))}
+
+
+ )
+}
+```
+
+## Testing Your Q&A System
+
+### Step 4: Test Document Processing
+
+1. **Upload Test Documents**:
+ - Upload a PDF manual or research paper
+ - Add a few web articles via URL
+ - Upload some text files with different topics
+
+2. **Test Question Types**:
+ ```
+ Factual: "What is the definition of X mentioned in the documents?"
+ Analytical: "What are the pros and cons of approach Y?"
+ Comparative: "How does method A compare to method B?"
+ Summarization: "Summarize the main findings"
+ ```
+
+3. **Verify Citations**:
+ - Check that citations appear in responses
+ - Verify citation numbers match source list
+ - Ensure sources show relevant metadata
+
+## Production Considerations
+
+### Performance Optimization
+
+```typescript
+// Implement caching for frequently asked questions
+const cacheKey = `qa:${collection}:${hashQuery(question)}`
+const cachedResponse = await redis.get(cacheKey)
+
+if (cachedResponse) {
+ return JSON.parse(cachedResponse)
+}
+
+// Cache response for 1 hour
+await redis.setex(cacheKey, 3600, JSON.stringify(response))
+```
+
+### Advanced Features
+
+1. **Follow-up Questions**:
+ ```typescript
+ // Track conversation context
+ const conversationHistory = messages.slice(-6) // Last 3 exchanges
+ ```
+
+2. **Answer Confidence Scoring**:
+ ```typescript
+ const confidence = calculateConfidence({
+ searchScore: searchResults.results[0]?.score || 0,
+ resultCount: searchResults.results.length,
+ chunkRelevance: avgChunkRelevance
+ })
+ ```
+
+3. **Multi-language Support**:
+ ```typescript
+ // Detect document language and adapt search
+ const detectedLanguage = await detectLanguage(question)
+ const searchResults = await client.search.documents({
+ q: question,
+ filters: {
+ AND: [{ key: 'language', value: detectedLanguage }]
+ }
+ })
+ ```
+
+This recipe provides a complete foundation for building document Q&A systems with accurate citations and source tracking.
+
+---
+
+*Customize this recipe based on your specific document types and use cases.*
\ No newline at end of file
diff --git a/apps/docs/cookbook/inf-chat-blog.mdx b/apps/docs/cookbook/inf-chat-blog.mdx
new file mode 100644
index 00000000..f5c2fcbe
--- /dev/null
+++ b/apps/docs/cookbook/inf-chat-blog.mdx
@@ -0,0 +1,4 @@
+---
+title: "Extending context windows in LLMs"
+url: "https://supermemory.ai/blog/extending-context-windows-in-llms/"
+---
diff --git a/apps/docs/cookbook/overview.mdx b/apps/docs/cookbook/overview.mdx
new file mode 100644
index 00000000..be320f56
--- /dev/null
+++ b/apps/docs/cookbook/overview.mdx
@@ -0,0 +1,64 @@
+---
+title: "Cookbook"
+description: "Complete examples and recipes for building with Supermemory"
+sidebarTitle: "Overview"
+---
+
+The Supermemory Cookbook provides complete, production-ready examples that show how to build real applications with Supermemory. Each recipe includes full implementation details, best practices, and common patterns.
+
+## Available Recipes
+
+
+ {/* Document Management Panel */}
+
+
+
+
+ {/* Q&A Interface */}
+
+
+ Document Collection
+ + {/* Collection Selector */} +
+
+ setCollection(e.target.value)}
+ className="w-full p-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
+ placeholder="e.g., company-docs"
+ />
+
+
+ {/* File Upload */}
+
+
+
+
+
+ {/* Upload Progress */}
+ {Object.keys(uploadProgress).length > 0 && (
+
+ {Object.entries(uploadProgress).map(([filename, progress]) => (
+
+ )}
+
+ {/* Document List */}
+
+
+ ))}
+
+ {filename}
+ {progress}%
+
+
+
+
+
+ {documents.map((doc) => (
+
+
+
+
+
+ ))}
+ {doc.title}
+
+ {doc.type} • {doc.status}
+
+
+
+
+
+ Ask Questions
+ + {/* Messages */} +
+ {messages.length === 0 && (
+
+
+ {/* Input */}
+
+
+ {documents.length === 0 && (
+
+ Upload documents and ask questions to get started!
+
+
+ )}
+
+ {messages.map((message) => (
+
+
+ Try asking:
+-
+
- "What are the main findings?" +
- "Summarize the key points" +
- "What does section 3 say about...?" +
+
+ ))}
+
+ {isLoading && (
+ {message.content}
+
+ {message.role === 'assistant' && sources.length > 0 && (
+ formatSources(sources)
+ )}
+
+
+ )}
+
+
+ Searching documents and generating answer...
+
+ + Upload documents first to enable questions +
+ )} +
+ {/* Header */}
+
+ )
+ }
+ ```
+
+
+
+ {/* Name Setup */}
+ {!userName && (
+ Personal AI Assistant
++ {userName ? `Hello ${userName}!` : 'Your AI that learns and remembers'} +
+
+
+
+ )}
+
+ {/* Messages */}
+
+ {messages.length === 0 && userName && (
+
+
+ {/* Input */}
+ {userName && (
+
+ )}
+
+
+ )}
+
+ {messages.map((message) => (
+ + Hi {userName}! I'm your personal AI assistant. I'll learn about your preferences, + work style, and interests as we chat. Feel free to share anything you'd like me to remember! +
+
+
+ Try saying:
+-
+
- "I work as a software engineer and prefer concise responses" +
- "Remember that I'm vegetarian and allergic to nuts" +
- "I usually work from 9-5 EST and take lunch at noon" +
+
+ ))}
+
+ {isLoading && (
+
+ {message.role === 'assistant' && (
+
+
+ AI
+
+ )}
+
+
+ {message.content}
+
+
+ )}
+
+
+
+ AI
+
+
+
+
+
+
+
+ 
+
+
+
+
+ )
+}
+
+{title}
+{description}
+
+
+
diff --git a/apps/docs/list-memories/examples/basic.mdx b/apps/docs/list-memories/examples/basic.mdx
new file mode 100644
index 00000000..c4358c44
--- /dev/null
+++ b/apps/docs/list-memories/examples/basic.mdx
@@ -0,0 +1,87 @@
+---
+title: "Basic Listing"
+description: "Simple memory retrieval across languages"
+---
+
+Simple memory retrieval examples for getting started with the list memories endpoint.
+
+## Basic Usage
+
+
+
++ supermemory [docs] +
+ ++ Meet the memory API for the AI era — scalable, powerful, affordable, and production-ready. +
+ +
+
+ + ```pip install supermemory``` + + ```npm install supermemory``` +
+
+
+
+
+
+
+
+
+ Free Tier
+100k tokens stored at no cost
+
+
+ Standard Plan
+$20/month fixed cost after exceeding free tier
+
+
+ Usage-Based
+Each thread includes 20k free tokens, then $1 per million tokens thereafter
+
+
+
+
+
+ | + Feature + | ++ Free + | ++ Standard + | +
|---|---|---|
| + Tokens Stored + | ++ 100k + | ++ Unlimited + | +
| + Conversations + | ++ 10 + | ++ Unlimited + | +
+- Memory Router: Keep your existing LLM client and just point it at Supermemory. We automatically fetch relevant memories and append them to your prompt.
+ +Both use the same memory engine underneath, and share a common key (`user_id`). Thus, anything you store via the API is available to the Router, and vice versa, as long as the `user_id` matches. +
user_id. Keep it consistent across Router and API calls to share the same memory pool.
+ metadata, categories, containerTags] + G --> H{Rerank?} + H -->|Yes| I[Apply Reranking] + H -->|No| J[Build Results with Chunks] + I --> J + J --> K[Return Documents + Chunks + Scores] +``` + +### Memory Search (`/v4/search`) Flow + +```mermaid +graph TD + A[Query Input] --> B[Query Rewriting + Embedding] + B --> C[Parallel Search Execution] + C --> D[Apply Filtering] + D --> E[Merge Results] + E --> F[Deduplication] + F --> G{Rerank?} + G -->|Yes| H[Apply Reranking] + G -->|No| I[Return Memories + Similarity] + H --> I +``` + +## Key Concepts You Need to Understand + +### 1. Thresholds (Sensitivity Control) + +Thresholds control result quality vs quantity: + +- **0.0** = Least sensitive (more results, lower quality) +- **1.0** = Most sensitive (fewer results, higher quality) + +```typescript +// Different threshold strategies +const broadSearch = await client.search.documents({ + q: "machine learning", + chunkThreshold: 0.2, // Return more chunks + documentThreshold: 0.1 // From more documents +}); + +const preciseSearch = await client.search.documents({ + q: "machine learning", + chunkThreshold: 0.8, // Only highly relevant chunks + documentThreshold: 0.7 // From closely matching documents +}); +``` + +### 2. Chunk Context vs Exact Matching + +By default, Supermemory returns chunks **with context** (surrounding text): + +```typescript +// Default: includes surrounding chunks for context +const contextualResults = await client.search.documents({ + q: "neural networks", + onlyMatchingChunks: false // Default +}); + +// Precise: only the exact matching text +const exactResults = await client.search.documents({ + q: "neural networks", + onlyMatchingChunks: true +}); +``` + +### 3. Query Rewriting & Reranking + +**Query Rewriting** (+400ms latency): +- Expands your query to find more relevant results +- "ML" becomes "machine learning artificial intelligence" +- Useful for abbreviations and domain-specific terms + +**Reranking**: +- Re-scores results using a different algorithm +- More accurate but slower +- Recommended for critical searches + +### 4. Container Tags vs Metadata Filters + +Two different filtering mechanisms: + +When to use container tags: + - The user understanding graph is built on top of container tags. **The graph is formed on top of container tags.** + - Container tags are used for organizational grouping and exact matching. + - They are useful for categorizing content and ensuring precise results. +When to use metadata filters: + - When you need flexible conditions beyond exact matches. + - Useful for filtering by attributes like date, author, or category. + +```typescript +// Container tags: Organizational grouping (exact array matching) +const userContent = await client.search.documents({ + q: "python tutorial", + containerTag "user_123" // Must match exactly +}); + +// Metadata filters: SQL-based queries (flexible conditions) +const filteredContent = await client.search.documents({ + q: "python tutorial", + filters: JSON.stringify({ + AND: [ + { key: "language", value: "python", negate: false }, + { key: "difficulty", value: "beginner", negate: false } + ] + }) +}); +``` + + + +