diff --git a/apps/docs/add-memories.mdx b/apps/docs/add-memories.mdx new file mode 100644 index 00000000..f10f51a1 --- /dev/null +++ b/apps/docs/add-memories.mdx @@ -0,0 +1,373 @@ +--- +title: "Ingesting context to supermemory" +sidebarTitle: "Add context" +description: "Add text, files, and URLs to Supermemory" +icon: "plus" +--- + +Send any raw content to Supermemory — conversations, documents, files, URLs. We extract the memories automatically. + + +**Use `customId`** to identify your content (conversation ID, document ID, etc.). This enables updates and prevents duplicates. + + +## Quick Start + + + + ```typescript + import Supermemory from 'supermemory'; + + const client = new Supermemory(); + + // Add text content + await client.add({ + content: "Machine learning enables computers to learn from data", + containerTag: "user_123", + metadata: { category: "ai" } + }); + + // Add a URL (auto-extracted) + await client.add({ + content: "https://youtube.com/watch?v=dQw4w9WgXcQ", + containerTag: "user_123" + }); + ``` + + + ```python + from supermemory import Supermemory + + client = Supermemory() + + # Add text content + client.add( + content="Machine learning enables computers to learn from data", + container_tag="user_123", + metadata={"category": "ai"} + ) + + # Add a URL (auto-extracted) + client.add( + content="https://youtube.com/watch?v=dQw4w9WgXcQ", + container_tag="user_123" + ) + ``` + + + ```bash + curl -X POST "https://api.supermemory.ai/v3/documents" \ + -H "Authorization: Bearer $SUPERMEMORY_API_KEY" \ + -H "Content-Type: application/json" \ + -d '{ + "content": "Machine learning enables computers to learn from data", + "containerTag": "user_123", + "metadata": {"category": "ai"} + }' + ``` + + + +**Response:** +```json +{ "id": "abc123", "status": "queued" } +``` + +--- + +## Updating Content + +Use `customId` to update existing documents or conversations. When you send content with the same `customId`, Supermemory intelligently processes only what's new. + +### Two ways to update: + +**Option 1: Send only the new content** +```typescript +// First request +await client.add({ + content: "user: Hi, I'm Sarah.\nassistant: Nice to meet you!", + customId: "conv_123", + containerTag: "user_sarah" +}); + +// Later: send only new messages +await client.add({ + content: "user: What's the weather?\nassistant: It's sunny today.", + customId: "conv_123", // Same ID — Supermemory links them + containerTag: "user_sarah" +}); +``` + +**Option 2: Send the full updated content** +```typescript +// Supermemory detects the diff and only processes new parts +await client.add({ + content: "user: Hi, I'm Sarah.\nassistant: Nice to meet you!\nuser: What's the weather?\nassistant: It's sunny today.", + customId: "conv_123", + containerTag: "user_sarah" +}); +``` + +Both work — choose what fits your architecture. + +### Replace entire document + +To completely replace a document's content (not append), use `memories.update()`: + +```typescript +// Replace the entire document content +await client.memories.update("doc_id_123", { + content: "Completely new content replacing everything", + metadata: { version: 2 } +}); +``` + +This triggers full reprocessing of the document. + +### Formatting conversations + +Format your conversations however you want. Supermemory handles any string format: + +```typescript +// Simple string +content: "user: Hello\nassistant: Hi there!" + +// JSON stringify +content: JSON.stringify(messages) + +// Template literal +content: messages.map(m => `${m.role}: ${m.content}`).join('\n') + +// Any format — just make it a string +content: formatConversation(messages) +``` + +--- + +## Upload Files + +Upload PDFs, images, and documents directly. + + + + ```typescript + import fs from 'fs'; + + await client.memories.uploadFile({ + file: fs.createReadStream('document.pdf'), + containerTags: 'user_123' + }); + ``` + + + ```python + with open('document.pdf', 'rb') as file: + client.memories.upload_file( + file=file, + container_tags='user_123' + ) + ``` + + + ```bash + curl -X POST "https://api.supermemory.ai/v3/documents/file" \ + -H "Authorization: Bearer $SUPERMEMORY_API_KEY" \ + -F "file=@document.pdf" \ + -F "containerTags=user_123" + ``` + + + +### Supported File Types + +| Type | Formats | Processing | +|------|---------|------------| +| Documents | PDF, DOC, DOCX, TXT, MD | Text extraction, OCR for scans | +| Images | JPG, PNG, GIF, WebP | OCR text extraction | +| Spreadsheets | CSV, Google Sheets | Structured data extraction | +| Videos | YouTube URLs, MP4 | Auto-transcription | + +**Limits:** 50MB max file size + +--- + +## Parameters + +| Parameter | Type | Description | +|-----------|------|-------------| +| `content` | string | **Required.** Any raw content — text, conversations, URLs, HTML | +| `customId` | string | **Recommended.** Your ID for the content (conversation ID, doc ID). Enables updates and deduplication | +| `containerTag` | string | Group by user/project. Required for user profiles | +| `metadata` | object | Key-value pairs for filtering (strings, numbers, booleans) | + + + + **Content Types:** + ```typescript + // Any text — conversations, notes, documents + { content: "Meeting notes from today's standup" } + { content: JSON.stringify(messages) } + + // URLs (auto-detected and extracted) + { content: "https://example.com/article" } + { content: "https://youtube.com/watch?v=abc123" } + + // Markdown, HTML, or any format + { content: "# Project Docs\n\n## Features\n- Real-time sync" } + ``` + + **Container Tags:** + ```typescript + // By user + { containerTag: "user_123" } + + // By project + { containerTag: "project_alpha" } + + // Hierarchical + { containerTag: "org_456_team_backend" } + ``` + + **Custom IDs (Recommended):** + ```typescript + // Use IDs from your system + { customId: "conv_abc123" } // Conversation ID + { customId: "doc_456" } // Document ID + { customId: "thread_789" } // Thread ID + { customId: "meeting_2024_01_15" } // Meeting ID + + // Updates: same customId = same document + // Supermemory only processes new/changed content + await client.add({ + content: "Updated content...", + customId: "doc_456" // Links to existing document + }); + ``` + + **Metadata:** + ```typescript + { + metadata: { + source: "slack", + author: "john", + priority: 1, + reviewed: true + } + } + ``` + - No nested objects or arrays + - Values: string, number, or boolean only + + + +--- + +## Processing Pipeline + +When you add content, Supermemory: + +1. **Validates** your request +2. **Stores** the document and queues for processing +3. **Extracts** content (OCR, transcription, web scraping) +4. **Chunks** into searchable memories +5. **Embeds** for vector search +6. **Indexes** for retrieval + +Track progress with `GET /v3/documents/{id}`: +```typescript +const doc = await client.memories.get("abc123"); +console.log(doc.status); // "queued" | "processing" | "done" +``` + + + + Process multiple documents with rate limiting: + + ```typescript + async function batchUpload(documents: Array<{id: string, content: string}>) { + const results = []; + + for (const doc of documents) { + try { + const result = await client.add({ + content: doc.content, + customId: doc.id, + containerTag: "batch_import" + }); + results.push({ id: doc.id, success: true, docId: result.id }); + } catch (error) { + results.push({ id: doc.id, success: false, error }); + } + + // Rate limit: 1 second between requests + await new Promise(r => setTimeout(r, 1000)); + } + + return results; + } + ``` + + **Tips:** + - Batch size: 3-5 documents at once + - Delay: 1-2 seconds between requests + - Use `customId` to track and deduplicate + + + + | Status | Error | Cause | + |--------|-------|-------| + | 400 | BadRequestError | Missing required fields, invalid parameters | + | 401 | AuthenticationError | Invalid or missing API key | + | 403 | PermissionDeniedError | Insufficient permissions | + | 429 | RateLimitError | Too many requests or quota exceeded | + | 500 | InternalServerError | Processing failure | + + ```typescript + import { BadRequestError, RateLimitError } from 'supermemory'; + + try { + await client.add({ content: "..." }); + } catch (error) { + if (error instanceof RateLimitError) { + // Wait and retry + await new Promise(r => setTimeout(r, 60000)); + } else if (error instanceof BadRequestError) { + // Fix request parameters + console.error("Invalid request:", error.message); + } + } + ``` + + + + **Single delete:** + ```typescript + await client.memories.delete("doc_id_123"); + ``` + + **Bulk delete by IDs:** + ```typescript + await client.memories.bulkDelete({ + ids: ["doc_1", "doc_2", "doc_3"] + }); + ``` + + **Bulk delete by container tag:** + ```typescript + // Delete all content for a user + await client.memories.bulkDelete({ + containerTags: ["user_123"] + }); + ``` + + Deletes are permanent — no recovery. + + + +--- + +## Next Steps + +- [Search Memories](/search) — Query your content +- [User Profiles](/user-profiles) — Get user context +- [Organizing & Filtering](/concepts/filtering) — Container tags and metadata diff --git a/apps/docs/add-memories/examples/basic.mdx b/apps/docs/add-memories/examples/basic.mdx index e87893fc..02cac11e 100644 --- a/apps/docs/add-memories/examples/basic.mdx +++ b/apps/docs/add-memories/examples/basic.mdx @@ -12,7 +12,7 @@ The most basic operation - adding plain text content. ```typescript TypeScript -const response = await client.memories.add({ +const response = await client.add({ content: "Artificial intelligence is transforming how we work and live" }); @@ -21,7 +21,7 @@ console.log(response); ``` ```python Python -response = client.memories.add( +response = client.add( content="Artificial intelligence is transforming how we work and live" ) @@ -47,7 +47,7 @@ Group related content using container tags. ```typescript TypeScript -const response = await client.memories.add({ +const response = await client.add({ content: "Q4 2024 revenue exceeded projections by 15%", containerTag: "financial_reports" }); @@ -57,7 +57,7 @@ console.log(response.id); ``` ```python Python -response = client.memories.add( +response = client.add( content="Q4 2024 revenue exceeded projections by 15%", container_tag="financial_reports" ) @@ -87,7 +87,7 @@ Attach metadata for better search and filtering. ```typescript TypeScript -await client.memories.add({ +await client.add({ content: "New onboarding flow reduces drop-off by 30%", containerTag: "product_updates", metadata: { @@ -98,7 +98,7 @@ await client.memories.add({ ``` ```python Python -client.memories.add( +client.add( content="New onboarding flow reduces drop-off by 30%", container_tag="product_updates", metadata={ @@ -136,7 +136,7 @@ const notes = [ const results = await Promise.all( notes.map(note => - client.memories.add({ + client.add({ content: note, containerTag: "meeting_2024_01_15" }) @@ -152,7 +152,7 @@ notes = [ ] for note in notes: - client.memories.add( + client.add( content=note, container_tag="meeting_2024_01_15" ) @@ -176,19 +176,19 @@ Process web pages, YouTube videos, and other URLs automatically. ```typescript TypeScript // Web page -await client.memories.add({ +await client.add({ content: "https://example.com/article", containerTag: "articles" }); // YouTube video (auto-transcribed) -await client.memories.add({ +await client.add({ content: "https://youtube.com/watch?v=dQw4w9WgXcQ", containerTag: "videos" }); // Google Docs -await client.memories.add({ +await client.add({ content: "https://docs.google.com/document/d/abc123/edit", containerTag: "docs" }); @@ -196,19 +196,19 @@ await client.memories.add({ ```python Python # Web page -client.memories.add( +client.add( content="https://example.com/article", container_tag="articles" ) # YouTube video (auto-transcribed) -client.memories.add( +client.add( content="https://youtube.com/watch?v=dQw4w9WgXcQ", container_tag="videos" ) # Google Docs -client.memories.add( +client.add( content="https://docs.google.com/document/d/abc123/edit", container_tag="docs" ) @@ -246,7 +246,7 @@ const markdown = ` - **Enterprise security** `; -await client.memories.add({ +await client.add({ content: markdown, containerTag: "docs" }); @@ -262,7 +262,7 @@ markdown = """ - **Enterprise security** """ -client.memories.add( +client.add( content=markdown, container_tag="docs" ) diff --git a/apps/docs/add-memories/overview.mdx b/apps/docs/add-memories/overview.mdx index 28778b0e..95031f30 100644 --- a/apps/docs/add-memories/overview.mdx +++ b/apps/docs/add-memories/overview.mdx @@ -53,7 +53,7 @@ client = Supermemory( ```typescript TypeScript // Add text content -const result = await client.memories.add({ +const result = await client.add({ content: "Machine learning enables computers to learn from data", containerTag: "ai-research", metadata: { priority: "high" } @@ -65,7 +65,7 @@ console.log(result); ```python Python # Add text content -result = client.memories.add( +result = client.add( content="Machine learning enables computers to learn from data", container_tags=["ai-research"], metadata={"priority": "high"} @@ -125,14 +125,14 @@ Add text content, URLs, or any supported format. ```typescript TypeScript -await client.memories.add({ +await client.add({ content: "Your content here", containerTag: "project" }); ``` ```python Python -client.memories.add( +client.add( content="Your content here", container_tags=["project"] ) @@ -245,7 +245,5 @@ curl -X PATCH "https://api.supermemory.ai/v3/documents/doc_id" \ ## Next Steps -- [Track Processing Status](/memory-api/track-progress) - Monitor document processing -- [Search Memories](/search/overview) - Search your content -- [List Memories](/list-memories/overview) - Browse stored memories -- [Update & Delete](/update-delete-memories/overview) - Manage memories +- [Memory Operations](/memory-operations) - Track status, list, update, and delete memories +- [Search Memories](/search) - Search your content diff --git a/apps/docs/ai-sdk/examples.mdx b/apps/docs/ai-sdk/examples.mdx index 61ad8d50..9eabbae9 100644 --- a/apps/docs/ai-sdk/examples.mdx +++ b/apps/docs/ai-sdk/examples.mdx @@ -4,7 +4,7 @@ description: "Complete examples showing how to use Supermemory with Vercel AI SD sidebarTitle: "Examples" --- -This page provides comprehensive examples of using Supermemory with the Vercel AI SDK, covering both Memory Tools and Infinite Chat approaches. +This page provides comprehensive examples of using Supermemory with the Vercel AI SDK, covering Memory Tools and User Profiles approaches. ## Personal Assistant with Memory Tools @@ -114,62 +114,6 @@ export async function POST(request: Request) { } ``` -## Infinite Chat for Documentation - -Create a documentation assistant with unlimited context: - - - -```typescript Documentation Chat -import { streamText } from 'ai' - -const supermemoryInfiniteChat = createOpenAI({ - baseUrl: 'https://api.supermemory.ai/v3/https://api.openai.com/v1', - apiKey: 'your-provider-api-key', - headers: { - 'x-supermemory-api-key': 'supermemory-api-key', - 'x-sm-conversation-id': 'conversation-id' - } -}) - -export async function POST(request: Request) { - const { messages } = await request.json() - - const result = await streamText({ - model: supermemoryInfiniteChat('gpt-5'), - messages, - system: `You are a documentation assistant. You have access to all previous - conversations and can reference earlier discussions. Help users understand - the documentation by building on previous context.` - }) - - return result.toAIStreamResponse() -} -``` - -```typescript Upload Documentation -// Separate endpoint to upload documentation to memory -import { addMemory } from '@supermemory/tools' - -export async function POST(request: Request) { - const { content, title, url } = await request.json() - - const memory = await addMemory({ - apiKey: process.env.SUPERMEMORY_API_KEY!, - content, - title, - url, - headers: { - 'x-sm-conversation-id': 'documentation' - } - }) - - return Response.json({ success: true, memory }) -} -``` - - - ## Multi-User Learning Assistant Build an assistant that learns from multiple users but keeps data separate: @@ -394,12 +338,6 @@ ANTHROPIC_API_KEY=your_anthropic_key - Use project headers to separate different use cases - Implement error handling for tool failures -### Infinite Chat -- Use conversation IDs to maintain separate chat contexts -- Include user IDs for personalized experiences -- Test with different providers to find the best fit for your use case -- Monitor token usage for cost optimization - ### General Tips - Start with simple examples and gradually add complexity - Use the search functionality to avoid duplicate memories @@ -413,7 +351,7 @@ ANTHROPIC_API_KEY=your_anthropic_key Advanced memory management with full API control - - Drop-in proxy for existing LLM applications + + Automatic personalization with user profiles diff --git a/apps/docs/ai-sdk/infinite-chat.mdx b/apps/docs/ai-sdk/infinite-chat.mdx index c382bcbf..4d67a86d 100644 --- a/apps/docs/ai-sdk/infinite-chat.mdx +++ b/apps/docs/ai-sdk/infinite-chat.mdx @@ -206,7 +206,7 @@ const infiniteChat = createOpenAI({ ## Next Steps - + Explore explicit memory control diff --git a/apps/docs/ai-sdk/memory-tools.mdx b/apps/docs/ai-sdk/memory-tools.mdx index cc84097f..f48d04f7 100644 --- a/apps/docs/ai-sdk/memory-tools.mdx +++ b/apps/docs/ai-sdk/memory-tools.mdx @@ -137,8 +137,8 @@ Each tool returns a result object: ## Next Steps - - Try automatic memory management + + Automatic personalization with profiles diff --git a/apps/docs/ai-sdk/overview.mdx b/apps/docs/ai-sdk/overview.mdx index 07d70e29..0c9a48f4 100644 --- a/apps/docs/ai-sdk/overview.mdx +++ b/apps/docs/ai-sdk/overview.mdx @@ -4,7 +4,7 @@ description: "Use Supermemory with Vercel AI SDK for seamless memory management" sidebarTitle: "Overview" --- -The Supermemory AI SDK provides native integration with Vercel's AI SDK through three approaches: **User Profiles** for automatic personalization, **Memory Tools** for agent-based interactions, and **Infinite Chat** for automatic context management. +The Supermemory AI SDK provides native integration with Vercel's AI SDK through two approaches: **User Profiles** for automatic personalization and **Memory Tools** for agent-based interactions. Check out the NPM page for more details @@ -68,50 +68,21 @@ const result = await streamText({ }) ``` -## Infinite Chat - -Automatic memory management for chat applications with unlimited context. - -```typescript -import { streamText } from "ai" - -const infiniteChat = createAnthropic({ - baseUrl: 'https://api.supermemory.ai/v3/https://api.anthropic.com/v1', - apiKey: 'your-provider-api-key', - headers: { - 'x-supermemory-api-key': 'supermemory-api-key', - 'x-sm-conversation-id': 'conversation-id' - } -}) - -const result = await streamText({ - model: infiniteChat("claude-3-sonnet"), - messages: [ - { role: "user", content: "What's my name?" } - ] -}) -``` - ## When to Use | Approach | Use Case | |----------|----------| | User Profiles | Personalized LLM responses with automatic user context | | Memory Tools | AI agents that need explicit memory control | -| Infinite Chat | Chat applications with automatic context | ## Next Steps - - + + Automatic personalization with profiles - + Agent-based memory management - - - Automatic context management - diff --git a/apps/docs/ai-sdk/user-profiles.mdx b/apps/docs/ai-sdk/user-profiles.mdx index fcfe4d7a..3afc41e0 100644 --- a/apps/docs/ai-sdk/user-profiles.mdx +++ b/apps/docs/ai-sdk/user-profiles.mdx @@ -289,7 +289,7 @@ The AI SDK middleware abstracts away the complexity of manual profile management Understand how profiles work conceptually - + Add explicit memory operations to your agents diff --git a/apps/docs/concepts/content-types.mdx b/apps/docs/concepts/content-types.mdx new file mode 100644 index 00000000..5776be5c --- /dev/null +++ b/apps/docs/concepts/content-types.mdx @@ -0,0 +1,214 @@ +--- +title: "Supported Content Types" +sidebarTitle: "Content Types" +description: "All the content formats Supermemory can ingest and process" +icon: "file-stack" +--- + +Supermemory automatically extracts and indexes content from various formats. Just send it—we handle the rest. + +## Text Content + +Raw text, conversations, notes, or any string content. + +```typescript +await client.add({ + content: "User prefers dark mode and uses vim keybindings", + containerTags: ["user_123"] +}); +``` + +**Best for:** Chat messages, user preferences, notes, logs, transcripts. + +--- + +## URLs & Web Pages + +Send a URL and Supermemory fetches, extracts, and indexes the content. + +```typescript +await client.add({ + content: "https://docs.example.com/api-reference", + containerTags: ["documentation"] +}); +``` + +**Extracts:** Article text, headings, metadata. Strips navigation, ads, boilerplate. + +--- + +## Documents + +### PDF + +```typescript +await client.add({ + content: pdfBase64, + contentType: "pdf", + title: "Q4 Financial Report" +}); +``` + +**Extracts:** Text, tables, headers. OCR for scanned documents. + +### Microsoft Office + +| Format | Extension | Content Type | +|--------|-----------|--------------| +| Word | `.docx` | `docx` | +| Excel | `.xlsx` | `xlsx` | +| PowerPoint | `.pptx` | `pptx` | + +```typescript +await client.add({ + content: docxBase64, + contentType: "docx", + title: "Product Roadmap" +}); +``` + +### Google Workspace + +Automatically handled via [Google Drive connector](/connectors/google-drive): +- Google Docs +- Google Sheets +- Google Slides + +--- + +## Code & Markdown + +```typescript +// Markdown +await client.add({ + content: markdownContent, + contentType: "md", + title: "README.md" +}); + +// Code files (auto-detected language) +await client.add({ + content: codeContent, + contentType: "code", + metadata: { language: "typescript" } +}); +``` + +**Extracts:** Structure, headings, code blocks with syntax awareness. + +Code is chunked using [code-chunk](https://github.com/supermemoryai/code-chunk), which understands AST boundaries to keep functions, classes, and logical blocks intact. See [Super RAG](/concepts/super-rag) for how Supermemory optimizes chunking for each content type. + +--- + +## Images + +```typescript +await client.add({ + content: imageBase64, + contentType: "image", + title: "Architecture Diagram" +}); +``` + +**Extracts:** OCR text, visual descriptions, diagram interpretations. + +**Supported:** PNG, JPG, JPEG, WebP, GIF + +--- + +## Audio & Video + +```typescript +// Audio +await client.add({ + content: audioBase64, + contentType: "audio", + title: "Customer Call Recording" +}); + +// Video +await client.add({ + content: videoBase64, + contentType: "video", + title: "Product Demo" +}); +``` + +**Extracts:** Transcription, speaker detection, topic segmentation. + +**Supported:** MP3, WAV, M4A, MP4, WebM + +--- + +## Structured Data + +### JSON + +```typescript +await client.add({ + content: JSON.stringify(userData), + contentType: "json", + title: "User Profile Data" +}); +``` + +### CSV + +```typescript +await client.add({ + content: csvContent, + contentType: "csv", + title: "Sales Data Q4" +}); +``` + +--- + +## File Upload + +For binary files, encode as base64: + +```typescript +import { readFileSync } from 'fs'; + +const file = readFileSync('./document.pdf'); +const base64 = file.toString('base64'); + +await client.add({ + content: base64, + contentType: "pdf", + title: "document.pdf" +}); +``` + +--- + +## Auto-Detection + +If you don't specify `contentType`, Supermemory auto-detects: + +```typescript +// URL detected automatically +await client.add({ content: "https://example.com/page" }); + +// Plain text detected automatically +await client.add({ content: "User said they prefer email contact" }); +``` + + +For binary content (files), always specify `contentType` for reliable processing. + + +--- + +## Content Limits + +| Type | Max Size | +|------|----------| +| Text | 1MB | +| Files | 50MB | +| URLs | Fetched content up to 10MB | + + +For large files, consider chunking or using [connectors](/connectors/overview) for automatic sync. + diff --git a/apps/docs/concepts/customization.mdx b/apps/docs/concepts/customization.mdx new file mode 100644 index 00000000..b84cae6b --- /dev/null +++ b/apps/docs/concepts/customization.mdx @@ -0,0 +1,159 @@ +--- +title: "Customizing for Your Use Case" +sidebarTitle: "Customization" +description: "Configure Supermemory's behavior for your specific application" +icon: "settings-2" +--- + +Configure how Supermemory processes and retrieves content for your specific use case. + +## Filter Prompts + +Tell Supermemory what content matters during ingestion. This helps filter and prioritize what gets indexed. + +```typescript +// Example: Brand guidelines assistant +await client.settings.update({ + shouldLLMFilter: true, + filterPrompt: `You are ingesting content for Brand.ai's brand guidelines system. + + Index: + - Official brand values and mission statements + - Approved tone of voice guidelines + - Logo usage and visual identity docs + - Approved messaging and taglines + + Skip: + - Draft documents and work-in-progress + - Outdated brand materials (pre-2024) + - Internal discussions about brand changes + - Competitor analysis docs` +}); +``` + + + + ```typescript + filterPrompt: `Personal AI assistant. Prioritize recent content, action items, + and personal context. Exclude spam and duplicates.` + ``` + + + ```typescript + filterPrompt: `Customer support agent. Prioritize verified solutions, official docs, + and resolved tickets. Exclude internal discussions and PII.` + ``` + + + ```typescript + filterPrompt: `Legal research assistant. Prioritize precedents, current regulations, + and approved contract language. Exclude privileged communications.` + ``` + + + ```typescript + filterPrompt: `Financial analysis assistant. Prioritize latest reports, verified data, + and regulatory filings. Exclude speculative data and MNPI.` + ``` + + + ```typescript + filterPrompt: `Healthcare information assistant. Prioritize evidence-based guidelines + and FDA-approved info. Exclude PHI and outdated recommendations.` + ``` + + + ```typescript + filterPrompt: `Developer documentation assistant. Prioritize current APIs, working + examples, and best practices. Exclude deprecated APIs and test fixtures.` + ``` + + + +--- + +## Chunk Size + +Control how documents are split into searchable pieces. Smaller chunks = more precise retrieval but less context per result. + +```typescript +await client.settings.update({ + chunkSize: 512 // -1 for default +}); +``` + +| Use Case | Chunk Size | Why | +|----------|------------|-----| +| Citations & references | `256-512` | Precise source attribution | +| Q&A / Support | `512-1024` | Balanced context | +| Long-form analysis | `1024-2048` | More context per chunk | +| Default | `-1` | Supermemory's optimized default | + + +Smaller chunks generate more memories per document. Larger chunks provide more context but may reduce precision. + + +--- + +## Connector Branding + +Show "Log in to **YourApp**" instead of "Log in to Supermemory" when users connect external services. + + + + 1. Create OAuth credentials in [Google Cloud Console](https://console.cloud.google.com/) + 2. Redirect URI: `https://api.supermemory.ai/v3/connections/google-drive/callback` + + ```typescript + await client.settings.update({ + googleDriveCustomKeyEnabled: true, + googleDriveClientId: "your-client-id.apps.googleusercontent.com", + googleDriveClientSecret: "your-client-secret" + }); + ``` + + + 1. Create integration at [Notion Developers](https://developers.notion.com/) + 2. Redirect URI: `https://api.supermemory.ai/v3/connections/notion/callback` + + ```typescript + await client.settings.update({ + notionCustomKeyEnabled: true, + notionClientId: "your-notion-client-id", + notionClientSecret: "your-notion-client-secret" + }); + ``` + + + 1. Register app in [Azure Portal](https://portal.azure.com/) + 2. Redirect URI: `https://api.supermemory.ai/v3/connections/onedrive/callback` + + ```typescript + await client.settings.update({ + onedriveCustomKeyEnabled: true, + onedriveClientId: "your-azure-app-id", + onedriveClientSecret: "your-azure-client-secret" + }); + ``` + + + +--- + +## API Reference + +```typescript +// Get current settings +const settings = await client.settings.get(); + +// Update settings +await client.settings.update({ + shouldLLMFilter: true, + filterPrompt: "...", + chunkSize: 512 +}); +``` + + +Settings are organization-wide. Changes apply to new content only—existing memories aren't reprocessed. + diff --git a/apps/docs/concepts/filtering.mdx b/apps/docs/concepts/filtering.mdx new file mode 100644 index 00000000..162f9b09 --- /dev/null +++ b/apps/docs/concepts/filtering.mdx @@ -0,0 +1,346 @@ +--- +title: "Organizing & Filtering Memories" +sidebarTitle: "Multi-Tenancy / Filtering" +description: "Use container tags and metadata to organize and retrieve memories" +icon: "users" +--- + +Supermemory provides two ways to organize your memories: + + + + **Organize memories** into isolated spaces by user, project, or workspace + + + **Query memories** by custom properties like category, status, or date + + + +Both can be used independently or together for precise filtering. + +--- + +## Container Tags + +Container tags create isolated memory spaces. Use them to separate memories by user, project, or any logical boundary. + +### Adding Memories with Tags + +```typescript +await client.add({ + content: "Meeting notes from Q1 planning", + containerTags: ["user_123"] +}); +``` + +### Searching with Tags + +```typescript +const results = await client.search.documents({ + q: "planning notes", + containerTags: ["user_123"] +}); +``` + + +Container tags use **exact array matching**. A memory tagged `["user_123", "project_a"]` won't match a search for just `["user_123"]`. + + +### Recommended Patterns + +| Pattern | Example | Use Case | +|---------|---------|----------| +| User isolation | `user_{userId}` | Per-user memories | +| Project grouping | `project_{projectId}` | Project-specific content | +| Hierarchical | `org_{orgId}_team_{teamId}` | Multi-level organization | + + + + ```typescript + // Multi-tenant SaaS - isolate by organization and user + await client.add({ + content: "Company policy document", + containerTags: ["org_acme_user_john"] + }); + + // Search only within that user's org context + const results = await client.search.documents({ + q: "vacation policy", + containerTags: ["org_acme_user_john"] + }); + + // Project-based isolation + await client.add({ + content: "Sprint 5 retrospective notes", + containerTags: ["project_mobile_app"] + }); + + // Time-based segmentation + await client.add({ + content: "Q1 2024 financial report", + containerTags: ["user_cfo_2024_q1"] + }); + ``` + + **API field differences:** + | Endpoint | Field | Type | + |----------|-------|------| + | `/v3/search` | `containerTags` | Array | + | `/v4/search` | `containerTag` | String | + | `/v3/documents/list` | `containerTags` | Array | + + + +--- + +## Metadata + +Metadata lets you attach custom properties to memories and filter by them later. + +### Adding Memories with Metadata + +```typescript +await client.add({ + content: "Technical design document for auth system", + containerTags: ["user_123"], + metadata: { + category: "engineering", + priority: "high", + year: 2024 + } +}); +``` + +### Searching with Metadata Filters + +Filters must be wrapped in `AND` or `OR` arrays: + +```typescript +const results = await client.search.documents({ + q: "design document", + containerTags: ["user_123"], + filters: { + AND: [ + { key: "category", value: "engineering" }, + { key: "priority", value: "high" } + ] + } +}); +``` + +### Filter Types + +| Type | Example | Description | +|------|---------|-------------| +| String equality | `{ key: "status", value: "published" }` | Exact match | +| String contains | `{ filterType: "string_contains", key: "title", value: "react" }` | Substring match | +| Numeric | `{ filterType: "numeric", key: "priority", value: "5", numericOperator: ">=" }` | Number comparison | +| Array contains | `{ filterType: "array_contains", key: "tags", value: "important" }` | Check array membership | + +### Combining Filters + +Use `AND` and `OR` for complex queries: + +```typescript +const results = await client.search.documents({ + q: "meeting notes", + filters: { + AND: [ + { key: "type", value: "meeting" }, + { + OR: [ + { key: "team", value: "engineering" }, + { key: "team", value: "product" } + ] + } + ] + } +}); +``` + +### Excluding Results + +Use `negate: true` to exclude matches: + +```typescript +const results = await client.search.documents({ + q: "documentation", + filters: { + AND: [ + { key: "status", value: "draft", negate: true } + ] + } +}); +``` + + + + **String contains (substring search):** + ```typescript + // Find documents with "machine learning" in the description + const results = await client.search.documents({ + q: "AI research", + filters: { + AND: [ + { + filterType: "string_contains", + key: "description", + value: "machine learning", + ignoreCase: true + } + ] + } + }); + ``` + + **Numeric comparisons:** + ```typescript + // Find high-priority items created after a specific date + const results = await client.search.documents({ + q: "tasks", + filters: { + AND: [ + { + filterType: "numeric", + key: "priority", + value: "7", + numericOperator: ">=" + }, + { + filterType: "numeric", + key: "created_timestamp", + value: "1704067200", // Unix timestamp + numericOperator: ">=" + } + ] + } + }); + ``` + + **Array contains (check array membership):** + ```typescript + // Find documents where a specific user is a participant + const results = await client.search.documents({ + q: "meeting notes", + filters: { + AND: [ + { + filterType: "array_contains", + key: "participants", + value: "alice@company.com" + } + ] + } + }); + ``` + + **Complex nested filters:** + ```typescript + // (category = "tech" OR category = "science") AND status != "archived" + const results = await client.search.documents({ + q: "research papers", + filters: { + AND: [ + { + OR: [ + { key: "category", value: "tech" }, + { key: "category", value: "science" } + ] + }, + { key: "status", value: "archived", negate: true } + ] + } + }); + ``` + + **Numeric operator negation mapping:** + When using `negate: true`, operators flip: + - `<` becomes `>=` + - `<=` becomes `>` + - `>` becomes `<=` + - `>=` becomes `<` + - `=` becomes `!=` + + + + **User's work documents from 2024:** + ```typescript + const results = await client.search.documents({ + q: "quarterly report", + containerTags: ["user_123"], + filters: { + AND: [ + { key: "category", value: "work" }, + { key: "type", value: "report" }, + { filterType: "numeric", key: "year", value: "2024", numericOperator: "=" } + ] + } + }); + ``` + + **Team meeting notes with specific participants:** + ```typescript + const results = await client.search.documents({ + q: "sprint planning", + containerTags: ["project_alpha"], + filters: { + AND: [ + { key: "type", value: "meeting" }, + { + OR: [ + { filterType: "array_contains", key: "participants", value: "alice" }, + { filterType: "array_contains", key: "participants", value: "bob" } + ] + } + ] + } + }); + ``` + + **Exclude drafts and deprecated content:** + ```typescript + const results = await client.search.documents({ + q: "documentation", + filters: { + AND: [ + { key: "status", value: "draft", negate: true }, + { filterType: "string_contains", key: "content", value: "deprecated", negate: true }, + { filterType: "array_contains", key: "tags", value: "archived", negate: true } + ] + } + }); + ``` + + + +--- + +## Quick Reference + +### When Adding Memories + +```typescript +await client.add({ + content: "Your content here", + containerTags: ["user_123"], // Isolation + metadata: { key: "value" } // Custom properties +}); +``` + +### When Searching + +```typescript +const results = await client.search.documents({ + q: "search query", + containerTags: ["user_123"], // Must match exactly + filters: { // Optional metadata filters + AND: [{ key: "status", value: "published" }] + } +}); +``` + +### Metadata Key Rules + +- Allowed characters: `a-z`, `A-Z`, `0-9`, `_`, `-`, `.` +- Max length: 64 characters +- No spaces or special characters diff --git a/apps/docs/concepts/graph-memory.mdx b/apps/docs/concepts/graph-memory.mdx new file mode 100644 index 00000000..6ac4940f --- /dev/null +++ b/apps/docs/concepts/graph-memory.mdx @@ -0,0 +1,140 @@ +--- +title: "How Graph Memory Works" +sidebarTitle: "Graph Memory" +description: "Automatic memory evolution, knowledge updates, and intelligent forgetting" +icon: "vector-square" +--- + +Supermemory builds a living knowledge graph where memories connect to other memories. Unlike traditional knowledge graphs with entity-relation-entity triples, Supermemory's graph is **facts built on top of other facts**. + +## Memory Relationships + +When you add content, Supermemory extracts facts and automatically connects them to existing memories through three relationship types: + +### Updates: Information Changes + +When new information contradicts existing knowledge: + +``` +Memory 1: "Alex works at Google as a software engineer" +Memory 2: "Alex just started at Stripe as a PM" + ↓ +Memory 2 UPDATES Memory 1 +``` + +The system tracks which memory is latest with `isLatest`, so searches return current information while preserving history. + +### Extends: Information Enriches + +When new information adds detail without replacing: + +``` +Memory 1: "Alex works at Stripe as a PM" +Memory 2: "Alex focuses on payments infrastructure and leads a team of 5" + ↓ +Memory 2 EXTENDS Memory 1 +``` + +Both memories remain valid—searches get richer context. + +### Derives: Information Infers + +When Supermemory infers new facts from patterns: + +``` +Memory 1: "Alex is a PM at Stripe" +Memory 2: "Alex frequently discusses payment APIs and fraud detection" + ↓ +Derived: "Alex likely works on Stripe's core payments product" +``` + +These inferences surface insights you didn't explicitly state. + +--- + +## Automatic Memory Extraction + +From a single conversation, Supermemory extracts multiple connected memories: + +**Input:** +> "Had a great call with Alex. He's enjoying the new PM role at Stripe, though the +> payments infrastructure work is intense. He moved to Seattle for the job—got a +> place in Capitol Hill. Wants to grab dinner next time I'm in town." + +**Extracted memories:** +- Alex works at Stripe as a PM +- Alex works on payments infrastructure *(extends role memory)* +- Alex lives in Seattle, Capitol Hill *(new fact)* +- Alex wants to meet for dinner *(episodic)* + +Each fact is connected to related memories automatically. + +--- + +## Automatic Forgetting + +Supermemory knows when memories become irrelevant: + +**Time-based forgetting**: Temporary facts are automatically forgotten when they expire. + +``` +"I have an exam tomorrow" + ↓ + After the exam date passes → automatically forgotten + +"Meeting with Alex at 3pm today" + ↓ + After today → automatically forgotten +``` + +**Contradiction resolution**: When new facts contradict old ones, the Update relationship ensures searches return current information. + +**Noise filtering**: Casual, non-meaningful content doesn't become permanent memories. + +--- + +## Memory Types + +Supermemory distinguishes memory types automatically: + +| Type | Example | Behavior | +|------|---------|----------| +| **Facts** | "Alex is a PM at Stripe" | Persists until updated | +| **Preferences** | "Alex prefers morning meetings" | Strengthens with repetition | +| **Episodes** | "Met Alex for coffee Tuesday" | Decays unless significant | + +--- + +## What You Don't Do + +All of this is automatic. You don't: +- Define relationships manually +- Tag memory types +- Clean up old memories +- Resolve contradictions + +Just add content and search naturally: + +```typescript +await client.add({ + content: "Alex mentioned he just started at Stripe" +}); + +const results = await client.search({ + query: "where does Alex work?" +}); +// → Stripe (latest), previously Google (historical) +``` + +--- + +## Learn More + + + + Deep dive into the architecture + + + Automatic summaries from the graph + + diff --git a/apps/docs/how-it-works.mdx b/apps/docs/concepts/how-it-works.mdx similarity index 96% rename from apps/docs/how-it-works.mdx rename to apps/docs/concepts/how-it-works.mdx index 318324b1..1830f7b0 100644 --- a/apps/docs/how-it-works.mdx +++ b/apps/docs/concepts/how-it-works.mdx @@ -1,7 +1,7 @@ --- title: "How Supermemory Works" description: "Understanding the knowledge graph architecture that powers intelligent memory" -icon: "brain" +icon: "cpu" --- @@ -142,11 +142,11 @@ Understanding the pipeline helps you optimize your usage: Now that you understand how Supermemory works: - + Start adding content to your knowledge graph - + Learn to query your knowledge effectively diff --git a/apps/docs/memory-vs-rag.mdx b/apps/docs/concepts/memory-vs-rag.mdx similarity index 99% rename from apps/docs/memory-vs-rag.mdx rename to apps/docs/concepts/memory-vs-rag.mdx index 699b906d..729355b6 100644 --- a/apps/docs/memory-vs-rag.mdx +++ b/apps/docs/concepts/memory-vs-rag.mdx @@ -2,6 +2,7 @@ title: "Memory vs RAG: Understanding the Difference" description: "Learn why agent memory and RAG are fundamentally different, and when to use each approach" sidebarTitle: "Memory vs RAG" +icon: "scale" --- Most developers confuse RAG (Retrieval-Augmented Generation) with agent memory. They're not the same thing, and using RAG for memory is why your agents keep forgetting important context. Let's understand the fundamental difference. @@ -193,7 +194,7 @@ Supermemory provides a unified platform that correctly handles both patterns: ### 1. Document Storage (RAG) ```python # Add a document for RAG-style retrieval -client.memories.add( +client.add( content="iPhone 15 has a 48MP camera and A17 Pro chip", # No user association - universal knowledge ) @@ -202,7 +203,7 @@ client.memories.add( ### 2. Memory Creation ```python # Add a user-specific memory -client.memories.add( +client.add( content="User prefers Android over iOS", container_tags=["user_123"], # User-specific metadata={ diff --git a/apps/docs/concepts/super-rag.mdx b/apps/docs/concepts/super-rag.mdx new file mode 100644 index 00000000..3e2aafc8 --- /dev/null +++ b/apps/docs/concepts/super-rag.mdx @@ -0,0 +1,171 @@ +--- +title: "SuperRAG (Managed RAG as a service)" +sidebarTitle: "SuperRAG" +description: "Supermemory provides a managed RAG solution - extraction, indexing, storing, and retrieval." +icon: "bolt" +--- + +Supermemory doesn't just store your content—it transforms it into optimized, searchable knowledge. Every upload goes through an intelligent pipeline that extracts, chunks, and indexes content in the ideal way for its type. + +## Automatic Content Intelligence + +When you add content, Supermemory: + +1. **Detects the content type** — PDF, code, markdown, images, video, etc. +2. **Extracts content optimally** — Uses type-specific extraction (OCR for images, transcription for audio) +3. **Chunks intelligently** — Applies the right chunking strategy for the content type +4. **Generates embeddings** — Creates vector representations for semantic search +5. **Builds relationships** — Connects new knowledge to existing memories + +```typescript +// Just add content — Supermemory handles the rest +await client.add({ + content: pdfBase64, + contentType: "pdf", + title: "Technical Documentation" +}); +``` + +No chunking strategies to configure. No embedding models to choose. It just works. + +--- + +## Smart Chunking by Content Type + +Different content types need different chunking strategies. Supermemory applies the optimal approach automatically: + +### Documents (PDF, DOCX) + +PDFs and documents are chunked by **semantic sections** — headers, paragraphs, and logical boundaries. This preserves context better than arbitrary character splits. + +``` +├── Executive Summary (chunk 1) +├── Introduction (chunk 2) +├── Section 1: Architecture +│ ├── Overview (chunk 3) +│ └── Components (chunk 4) +└── Conclusion (chunk 5) +``` + +### Code + +Code is chunked using [code-chunk](https://github.com/supermemoryai/code-chunk), our open-source library that understands AST (Abstract Syntax Tree) boundaries: + +- Functions and methods stay intact +- Classes are chunked by method +- Import statements grouped separately +- Comments attached to their code blocks + +```typescript +// A 500-line file becomes meaningful chunks: +// - Imports + type definitions +// - Each function as a separate chunk +// - Class methods individually indexed +``` + +This means searching for "authentication middleware" finds the actual function, not a random slice of code. + +### Web Pages + +URLs are fetched, cleaned of navigation/ads, and chunked by article structure — headings, paragraphs, lists. + +### Markdown + +Chunked by heading hierarchy, preserving the document structure. + +See [Content Types](/concepts/content-types) for the full list of supported formats. + +--- + +## Hybrid Memory + RAG + +Supermemory combines the best of both approaches in every search: + + + + - Finds similar document chunks + - Great for knowledge retrieval + - Stateless — same results for everyone + + + + - Extracts and tracks user facts + - Understands temporal context + - Personalizes results per user + + + +With `searchMode: "hybrid"` (the default), you get both: + +```typescript +const results = await client.search({ + q: "how do I deploy the app?", + containerTag: "user_123", + searchMode: "hybrid" +}); + +// Returns: +// - Deployment docs from your knowledge base (RAG) +// - User's previous deployment preferences (Memory) +// - Their specific environment configs (Memory) +``` + +--- + +## Search Optimization + +Two flags give you fine-grained control over result quality: + +### Reranking + +Re-scores results using a cross-encoder model for better relevance: + +```typescript +const results = await client.search({ + q: "complex technical question", + rerank: true // +~100ms, significantly better ranking +}); +``` + +**When to use:** Complex queries, technical documentation, when precision matters more than speed. + +### Query Rewriting + +Expands your query to capture more relevant results: + +```typescript +const results = await client.search({ + q: "how to auth", + rewriteQuery: true // Expands to "authentication login oauth jwt..." +}); +``` + +**When to use:** Short queries, user-facing search, when recall matters. + +--- + +## Why It's "Super" + +| Traditional RAG | SUPER RAG | +|-----------------|-----------| +| Manual chunking config | Automatic per content type | +| One-size-fits-all splits | AST-aware code chunking | +| Just document retrieval | Hybrid memory + documents | +| Static embeddings | Relationship-aware graph | +| Generic search | Rerank + query rewriting | + +You focus on building your product. Supermemory handles the RAG complexity. + +--- + +## Next Steps + + + + All supported formats and how they're processed + + + + Search parameters and optimization + + diff --git a/apps/docs/concepts/user-profiles.mdx b/apps/docs/concepts/user-profiles.mdx new file mode 100644 index 00000000..7b01b41e --- /dev/null +++ b/apps/docs/concepts/user-profiles.mdx @@ -0,0 +1,135 @@ +--- +title: "User Profiles" +sidebarTitle: "User Profiles" +description: "Automatically maintained context about your users" +icon: "circle-user" +--- + +User profiles are **automatically maintained collections of facts about your users** that Supermemory builds from all their interactions. Think of it as a persistent "about me" document that's always up-to-date. + + + + No search needed — comprehensive user info always ready + + + Profiles update as users interact with your system + + + +## Why Profiles? + +Traditional memory systems rely entirely on search: + +| Problem | Search Only | With Profiles | +|---------|------------|---------------| +| Context retrieval | 3-5 queries | 1 call | +| Response time | 200-500ms | 50-100ms | +| Basic user info | Requires specific queries | Always available | + +**Search is too narrow**: When you search for "project updates", you miss that the user prefers bullet points, works in PST, and uses specific terminology. + +**Profiles provide the foundation**: Instead of searching for basic context, profiles give your LLM a complete picture of who the user is. + +--- + +## Static vs Dynamic + +Profiles separate two types of information: + +### Static Profile + +Long-term, stable facts: + +- "Sarah is a senior software engineer at TechCorp" +- "Sarah specializes in distributed systems" +- "Sarah prefers technical docs over video tutorials" + +### Dynamic Profile + +Recent context and temporary states: + +- "Sarah is migrating the payment service to microservices" +- "Sarah is preparing for a conference talk next month" +- "Sarah is debugging a memory leak in auth service" + +--- + +## How It Works + +Profiles are built automatically through ingestion: + +1. **Ingest content** — Users add documents, chat, or any content +2. **Extract facts** — AI analyzes content for facts about the user +3. **Update profile** — System adds, updates, or removes facts +4. **Always current** — Profiles reflect the latest information + + +You don't manually manage profiles — they build themselves as users interact. + + +--- + +## Profiles + Search + +Profiles don't replace search — they complement it: + +- **Profile** = broad foundation (who the user is, preferences, background) +- **Search** = specific details (exact memories matching a query) + +### Example + +User asks: **"Can you help me debug this?"** + +**Without profiles**: LLM has no context about expertise, projects, or preferences. + +**With profiles**: LLM knows: +- Senior engineer (adjust technical level) +- Working on payment service (likely context) +- Prefers CLI tools (tool suggestions) +- Recent memory leak issues (possible connection) + +--- + +## Use Cases + +### Personalized AI Assistants + +Profiles provide: expertise level, communication preferences, tools used, current projects. + +```typescript +const systemPrompt = `You are assisting ${userName}. + +Background: ${profile.static.join('\n')} +Current focus: ${profile.dynamic.join('\n')} + +Adjust responses to their expertise and preferences.`; +``` + +### Customer Support + +Profiles provide: product usage, previous issues, tech proficiency. + +- No more "let me look up your account" +- Agents immediately understand context +- AI support references past interactions naturally + +### Educational Platforms + +Profiles provide: learning style, completed courses, strengths/weaknesses. + +### Development Tools + +Profiles provide: preferred languages, coding style, current project context. + +--- + +## Next Steps + + + + Learn how to fetch and use profiles + + + Automatic profile injection with AI SDK + + diff --git a/apps/docs/connectors/overview.mdx b/apps/docs/connectors/overview.mdx index 046cc305..f36c39ad 100644 --- a/apps/docs/connectors/overview.mdx +++ b/apps/docs/connectors/overview.mdx @@ -2,6 +2,7 @@ title: "Connectors Overview" description: "Integrate Google Drive, Notion, OneDrive, GitHub and Web Crawler to automatically sync documents into your knowledge base" sidebarTitle: "Overview" +icon: "layers" --- Connect external platforms to automatically sync documents into Supermemory. Supported connectors include Google Drive, Notion, OneDrive, GitHub and Web Crawler with real-time synchronization and intelligent content processing. diff --git a/apps/docs/connectors/troubleshooting.mdx b/apps/docs/connectors/troubleshooting.mdx index 847a7987..ec62fab7 100644 --- a/apps/docs/connectors/troubleshooting.mdx +++ b/apps/docs/connectors/troubleshooting.mdx @@ -1,6 +1,8 @@ --- title: "Connector Troubleshooting" +sidebarTitle: "Troubleshooting" description: "Diagnose and resolve common issues with Google Drive, Notion, and OneDrive connectors" +icon: "wrench" --- Quick guide to resolve common connector issues with authentication, syncing, and permissions. diff --git a/apps/docs/cookbook/ai-sdk-integration.mdx b/apps/docs/cookbook/ai-sdk-integration.mdx index 8bdafef7..d6853210 100644 --- a/apps/docs/cookbook/ai-sdk-integration.mdx +++ b/apps/docs/cookbook/ai-sdk-integration.mdx @@ -3,7 +3,7 @@ title: "AI SDK Integration" description: "Complete examples showing how to use Supermemory with Vercel AI SDK for building intelligent applications" --- -This page provides comprehensive examples of using Supermemory with the Vercel AI SDK, covering both Memory Tools and Infinite Chat approaches. +This page provides comprehensive examples of using Supermemory with the Vercel AI SDK, covering Memory Tools and User Profiles approaches. ## Personal Assistant with Memory Tools @@ -113,62 +113,6 @@ export async function POST(request: Request) { } ``` -## Infinite Chat for Documentation - -Create a documentation assistant with unlimited context: - - - -```typescript Documentation Chat -import { streamText } from 'ai' - -const infiniteChat = createOpenAI({ - baseUrl: 'https://api.supermemory.ai/v3/https://api.openai.com/v1', - apiKey: 'your-provider-api-key', - headers: { - 'x-supermemory-api-key': 'supermemory-api-key', - 'x-sm-conversation-id': 'conversation-id' - } -}) - -export async function POST(request: Request) { - const { messages } = await request.json() - - const result = await streamText({ - model: infiniteChat('gpt-5'), - messages, - system: `You are a documentation assistant. You have access to all previous - conversations and can reference earlier discussions. Help users understand - the documentation by building on previous context.` - }) - - return result.toAIStreamResponse() -} -``` - -```typescript Upload Documentation -// Separate endpoint to upload documentation to memory -import { addMemory } from '@supermemory/tools' - -export async function POST(request: Request) { - const { content, title, url } = await request.json() - - const memory = await addMemory({ - apiKey: process.env.SUPERMEMORY_API_KEY!, - content, - title, - url, - headers: { - 'x-sm-conversation-id': 'documentation' - } - }) - - return Response.json({ success: true, memory }) -} -``` - - - ## Multi-User Learning Assistant Build an assistant that learns from multiple users but keeps data separate: @@ -391,12 +335,6 @@ ANTHROPIC_API_KEY=your_anthropic_key - Use project headers to separate different use cases - Implement error handling for tool failures -### Infinite Chat -- Use conversation IDs to maintain separate chat contexts -- Include user IDs for personalized experiences -- Test with different providers to find the best fit for your use case -- Monitor token usage for cost optimization - ### General Tips - Start with simple examples and gradually add complexity - Use the search functionality to avoid duplicate memories @@ -410,7 +348,7 @@ ANTHROPIC_API_KEY=your_anthropic_key Advanced memory management with full API control - - Drop-in proxy for existing LLM applications + + Automatic personalization with user profiles diff --git a/apps/docs/cookbook/customer-support.mdx b/apps/docs/cookbook/customer-support.mdx index 32e0417e..b1643556 100644 --- a/apps/docs/cookbook/customer-support.mdx +++ b/apps/docs/cookbook/customer-support.mdx @@ -70,7 +70,7 @@ A customer support bot that: metadata?: Record }) { try { - const result = await client.memories.add({ + const result = await client.add({ content: `${interaction.type.toUpperCase()}: ${interaction.content}`, containerTag: this.getContainerTag(customerId), metadata: { @@ -146,7 +146,7 @@ A customer support bot that: try { const issueContent = `ISSUE: ${issue.subject}\n\nDescription: ${issue.description}\nCategory: ${issue.category}\nPriority: ${issue.priority}\nStatus: ${issue.status}` - const result = await client.memories.add({ + const result = await client.add({ content: issueContent, containerTag: this.getContainerTag(customerId), metadata: { @@ -232,7 +232,7 @@ A customer support bot that: try: content = f"{interaction['type'].upper()}: {interaction['content']}" - result = self.client.memories.add( + result = self.client.add( content=content, container_tag=self._get_container_tag(customer_id), metadata={ @@ -309,7 +309,7 @@ Category: {issue['category']} Priority: {issue['priority']} Status: {issue['status']}""" - result = self.client.memories.add( + result = self.client.add( content=issue_content, container_tag=self._get_container_tag(customer_id), metadata={ diff --git a/apps/docs/cookbook/document-qa.mdx b/apps/docs/cookbook/document-qa.mdx index d11e947b..e18b7c2f 100644 --- a/apps/docs/cookbook/document-qa.mdx +++ b/apps/docs/cookbook/document-qa.mdx @@ -71,7 +71,7 @@ A document Q&A system that: async uploadURL({ url, collection, metadata = {} }: { url: string, collection: string, metadata?: Record }) { try { - const result = await client.memories.add({ + const result = await client.add({ content: url, containerTag: collection, metadata: { @@ -216,7 +216,7 @@ A document Q&A system that: metadata = {} try: - result = self.client.memories.add( + result = self.client.add( content=url, container_tag=collection, metadata={ diff --git a/apps/docs/cookbook/overview.mdx b/apps/docs/cookbook/overview.mdx index 80ec57a1..a36dcfb6 100644 --- a/apps/docs/cookbook/overview.mdx +++ b/apps/docs/cookbook/overview.mdx @@ -53,7 +53,7 @@ We're working on more comprehensive recipes. Have a suggestion? [Let us know!](m Can't find what you're looking for? -- Browse [Search Examples](/search/examples/document-search) for specific feature usage +- Browse [Search](/search) for specific feature usage - Check the [AI SDK Examples](/cookbook/ai-sdk-integration) for complete implementations - Reach out to [support](mailto:support@supermemory.ai) for help diff --git a/apps/docs/cookbook/personal-assistant.mdx b/apps/docs/cookbook/personal-assistant.mdx index 7d5f256b..d4522590 100644 --- a/apps/docs/cookbook/personal-assistant.mdx +++ b/apps/docs/cookbook/personal-assistant.mdx @@ -9,7 +9,7 @@ Build a personal AI assistant that learns and remembers everything about the use A personal AI assistant that: - **Remembers user preferences** (dietary restrictions, work schedule, communication style) -- **Maintains context** across multiple chat sessions +- **Maintains context** across multiple chat sessions - **Provides personalized recommendations** based on user history - **Handles multiple conversation topics** while maintaining context @@ -169,7 +169,7 @@ This searches the user's memory store for context relevant to their current mess ```python async def add_user_memory(content: str, container_tag: str, email: str = None): try: - supermemory_client.memories.add( + supermemory_client.add( content=content, container_tag=container_tag, metadata={"type": "personal_info", "email": normalize_email(email) if email else None} @@ -196,7 +196,7 @@ Stores new information about the user. async def chat_endpoint(data: dict): messages = data.get("messages", []) email = data.get("email") - + if not messages: raise HTTPException(status_code=400, detail="No messages provided") if not email: @@ -216,7 +216,7 @@ This endpoint receives the chat request. It expects: user_id = stable_user_id_from_email(email) except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) - + container_tag = f"user_{user_id}" ``` @@ -229,7 +229,7 @@ The container tag (`user_abc123`) isolates this user's memories from everyone el ```python user_message = messages[-1]["content"] memory_context = await search_user_memories(user_message, container_tag) - + enhanced_messages = [ {"role": "system", "content": f"{SYSTEM_PROMPT}\n\n{memory_context}"} ] + messages @@ -308,7 +308,7 @@ After streaming completes, check if the user explicitly asked to remember someth ```python return StreamingResponse(generate(), media_type="text/plain") - + except Exception as e: raise HTTPException(status_code=500, detail=str(e)) ``` @@ -360,11 +360,11 @@ st.markdown("*Your AI that learns and remembers*") with st.sidebar: st.header("👤 User Profile") - + if not st.session_state.user_name or not st.session_state.email: name = st.text_input("What should I call you?") email = st.text_input("Email", placeholder="you@example.com") - + if st.button("Get Started"): if name and email: st.session_state.user_name = name @@ -388,12 +388,12 @@ if st.session_state.user_name and st.session_state.email: for message in st.session_state.messages: with st.chat_message(message["role"]): st.markdown(message["content"]) - + if prompt := st.chat_input("Message..."): st.session_state.messages.append({"role": "user", "content": prompt}) with st.chat_message("user"): st.markdown(prompt) - + with st.chat_message("assistant"): try: response = requests.post( @@ -405,7 +405,7 @@ if st.session_state.user_name and st.session_state.email: stream=True, timeout=30 ) - + if response.status_code == 200: full_response = "" for line in response.iter_lines(): @@ -416,7 +416,7 @@ if st.session_state.user_name and st.session_state.email: full_response += data['content'] except: continue - + st.markdown(full_response) st.session_state.messages.append({"role": "assistant", "content": full_response}) else: @@ -544,7 +544,7 @@ Without email, we can't maintain personalization across sessions. const containerTag = `user_${email.toLowerCase().trim()}` ``` -Convert email to a container tag for memory isolation. +Convert email to a container tag for memory isolation. **Simpler than Python**: We skip UUID generation here for simplicity. In production, you might want to hash the email for privacy: @@ -646,10 +646,10 @@ Catches any errors (API failures, tool errors, etc.) and returns a clean error r | **Streaming** | Manual SSE formatting | `toAIStreamResponse()` handles it | | **Error Handling** | Try/catch in each function | AI SDK handles tool errors | -**Python = Manual Control** +**Python = Manual Control** You explicitly search and add memories. More control, more code. -**TypeScript = AI-Driven** +**TypeScript = AI-Driven** The AI decides when to use tools. Less code, more "magic." ### Step 3: Chat UI @@ -668,12 +668,12 @@ export default function ChatPage() { const [userName, setUserName] = useState('') const [tempEmail, setTempEmail] = useState('') const [tempName, setTempName] = useState('') - + const { messages, input, handleInputChange, handleSubmit } = useChat({ api: '/api/chat', body: { email } }) - + if (!email) { return (
@@ -708,7 +708,7 @@ export default function ChatPage() {
) } - + return (
@@ -716,8 +716,8 @@ export default function ChatPage() {
@@ -725,7 +725,7 @@ export default function ChatPage() {
))}
- +
-