From ac72eb5ecc8e1d9f73263e206d83cafb59c4898a Mon Sep 17 00:00:00 2001 From: Parshva Daftari <89991302+parshvadaftari@users.noreply.github.com> Date: Thu, 18 Sep 2025 21:03:17 +0530 Subject: [PATCH] Aspen theme for 1.x (#3473) --- docs/components/llms/overview.mdx | 4 +- docs/components/rerankers/config.mdx | 145 +++ docs/components/rerankers/custom-prompts.mdx | 217 +++++ docs/components/rerankers/models/cohere.mdx | 116 +++ .../rerankers/models/huggingface.mdx | 352 +++++++ .../rerankers/models/llm_reranker.mdx | 491 ++++++++++ .../rerankers/models/sentence_transformer.mdx | 162 ++++ docs/components/rerankers/optimization.mdx | 312 +++++++ docs/components/rerankers/overview.mdx | 52 ++ docs/docs.json | 877 +++++++++++------- docs/examples.mdx | 2 +- docs/integrations.mdx | 22 - docs/integrations/keywords.mdx | 2 +- docs/introduction.mdx | 4 +- docs/logo/Favicon copy.png | Bin 0 -> 67249 bytes docs/logo/favicon_old.png | Bin 0 -> 67249 bytes docs/migration/api-changes.mdx | 551 +++++++++++ docs/migration/breaking-changes.mdx | 404 ++++++++ docs/migration/v0-to-v1.mdx | 491 ++++++++++ .../features/metadata-filtering.mdx | 389 ++++++++ docs/open-source/features/overview.mdx | 6 +- docs/open-source/features/reranker-search.mdx | 418 +++++++++ docs/open-source/graph_memory/overview.mdx | 2 +- docs/platform/features/platform-overview.mdx | 20 +- docs/v0x/components/embedders/config.mdx | 101 ++ .../embedders/models/aws_bedrock.mdx | 62 ++ .../embedders/models/azure_openai.mdx | 125 +++ .../components/embedders/models/google_AI.mdx | 69 ++ .../embedders/models/huggingface.mdx | 75 ++ .../components/embedders/models/langchain.mdx | 196 ++++ .../components/embedders/models/lmstudio.mdx | 38 + .../components/embedders/models/ollama.mdx | 73 ++ .../components/embedders/models/openai.mdx | 72 ++ .../components/embedders/models/together.mdx | 45 + .../components/embedders/models/vertexai.mdx | 55 ++ docs/v0x/components/embedders/overview.mdx | 34 + docs/v0x/components/llms/config.mdx | 137 +++ docs/v0x/components/llms/models/anthropic.mdx | 67 ++ .../components/llms/models/aws_bedrock.mdx | 43 + .../components/llms/models/azure_openai.mdx | 161 ++++ docs/v0x/components/llms/models/deepseek.mdx | 55 ++ docs/v0x/components/llms/models/google_AI.mdx | 74 ++ docs/v0x/components/llms/models/groq.mdx | 68 ++ docs/v0x/components/llms/models/langchain.mdx | 109 +++ docs/v0x/components/llms/models/litellm.mdx | 34 + docs/v0x/components/llms/models/lmstudio.mdx | 83 ++ .../v0x/components/llms/models/mistral_AI.mdx | 66 ++ docs/v0x/components/llms/models/ollama.mdx | 60 ++ docs/v0x/components/llms/models/openai.mdx | 99 ++ docs/v0x/components/llms/models/sarvam.mdx | 73 ++ docs/v0x/components/llms/models/together.mdx | 35 + docs/v0x/components/llms/models/vllm.mdx | 107 +++ docs/v0x/components/llms/models/xAI.mdx | 41 + docs/v0x/components/llms/overview.mdx | 63 ++ docs/v0x/components/vectordbs/config.mdx | 128 +++ docs/v0x/components/vectordbs/dbs/azure.mdx | 179 ++++ docs/v0x/components/vectordbs/dbs/baidu.mdx | 67 ++ docs/v0x/components/vectordbs/dbs/chroma.mdx | 48 + .../components/vectordbs/dbs/databricks.mdx | 130 +++ .../vectordbs/dbs/elasticsearch.mdx | 109 +++ docs/v0x/components/vectordbs/dbs/faiss.mdx | 72 ++ .../components/vectordbs/dbs/langchain.mdx | 112 +++ docs/v0x/components/vectordbs/dbs/milvus.mdx | 43 + docs/v0x/components/vectordbs/dbs/mongodb.mdx | 45 + .../vectordbs/dbs/neptune_analytics.mdx | 42 + .../components/vectordbs/dbs/opensearch.mdx | 81 ++ .../v0x/components/vectordbs/dbs/pgvector.mdx | 87 ++ .../v0x/components/vectordbs/dbs/pinecone.mdx | 98 ++ docs/v0x/components/vectordbs/dbs/qdrant.mdx | 89 ++ docs/v0x/components/vectordbs/dbs/redis.mdx | 92 ++ .../components/vectordbs/dbs/s3_vectors.mdx | 78 ++ .../v0x/components/vectordbs/dbs/supabase.mdx | 170 ++++ .../vectordbs/dbs/upstash-vector.mdx | 70 ++ docs/v0x/components/vectordbs/dbs/valkey.mdx | 49 + .../components/vectordbs/dbs/vectorize.mdx | 45 + .../components/vectordbs/dbs/vertex_ai.mdx | 48 + .../v0x/components/vectordbs/dbs/weaviate.mdx | 47 + docs/v0x/components/vectordbs/overview.mdx | 55 ++ .../core-concepts/memory-operations/add.mdx | 153 +++ .../memory-operations/delete.mdx | 141 +++ .../memory-operations/search.mdx | 124 +++ .../memory-operations/update.mdx | 117 +++ docs/v0x/core-concepts/memory-types.mdx | 49 + docs/v0x/examples/ai_companion_js.mdx | 126 +++ docs/v0x/examples/aws_example.mdx | 130 +++ .../aws_neptune_analytics_hybrid_store.mdx | 120 +++ docs/v0x/examples/chrome-extension.mdx | 55 ++ .../v0x/examples/collaborative-task-agent.mdx | 123 +++ docs/v0x/examples/customer-support-agent.mdx | 111 +++ docs/v0x/examples/eliza_os.mdx | 73 ++ docs/v0x/examples/email_processing.mdx | 186 ++++ docs/v0x/examples/llama-index-mem0.mdx | 173 ++++ .../llamaindex-multiagent-learning-system.mdx | 360 +++++++ docs/v0x/examples/mem0-agentic-tool.mdx | 227 +++++ docs/v0x/examples/mem0-demo.mdx | 68 ++ .../mem0-google-adk-healthcare-assistant.mdx | 293 ++++++ docs/v0x/examples/mem0-mastra.mdx | 126 +++ docs/v0x/examples/mem0-openai-voice-demo.mdx | 538 +++++++++++ docs/v0x/examples/mem0-with-ollama.mdx | 72 ++ .../memory-guided-content-writing.mdx | 218 +++++ docs/v0x/examples/multimodal-demo.mdx | 31 + docs/v0x/examples/openai-inbuilt-tools.mdx | 312 +++++++ docs/v0x/examples/personal-ai-tutor.mdx | 111 +++ .../examples/personal-travel-assistant.mdx | 202 ++++ .../examples/personalized-deep-research.mdx | 67 ++ .../personalized-search-tavily-mem0.mdx | 190 ++++ docs/v0x/examples/youtube-assistant.mdx | 56 ++ docs/v0x/faqs.mdx | 267 ++++++ docs/v0x/images/add_architecture.png | Bin 0 -> 282700 bytes docs/v0x/images/search_architecture.png | Bin 0 -> 232226 bytes docs/v0x/integrations/agentops.mdx | 173 ++++ docs/v0x/integrations/agno.mdx | 203 ++++ docs/v0x/integrations/autogen.mdx | 138 +++ docs/v0x/integrations/aws-bedrock.mdx | 130 +++ docs/v0x/integrations/crewai.mdx | 168 ++++ docs/v0x/integrations/dify.mdx | 34 + docs/v0x/integrations/elevenlabs.mdx | 454 +++++++++ docs/v0x/integrations/flowise.mdx | 126 +++ docs/v0x/integrations/google-ai-adk.mdx | 287 ++++++ docs/v0x/integrations/keywords.mdx | 140 +++ docs/v0x/integrations/langchain-tools.mdx | 336 +++++++ docs/v0x/integrations/langchain.mdx | 171 ++++ docs/v0x/integrations/langgraph.mdx | 172 ++++ docs/v0x/integrations/livekit.mdx | 238 +++++ docs/v0x/integrations/llama-index.mdx | 218 +++++ docs/v0x/integrations/mastra.mdx | 134 +++ docs/v0x/integrations/openai-agents-sdk.mdx | 234 +++++ docs/v0x/integrations/pipecat.mdx | 218 +++++ docs/v0x/integrations/raycast.mdx | 45 + docs/v0x/integrations/vercel-ai-sdk.mdx | 259 ++++++ docs/v0x/introduction.mdx | 98 ++ docs/v0x/open-source/node-quickstart.mdx | 455 +++++++++ docs/v0x/open-source/overview.mdx | 28 + docs/v0x/open-source/python-quickstart.mdx | 546 +++++++++++ docs/v0x/quickstart.mdx | 246 +++++ 135 files changed, 19053 insertions(+), 360 deletions(-) create mode 100644 docs/components/rerankers/config.mdx create mode 100644 docs/components/rerankers/custom-prompts.mdx create mode 100644 docs/components/rerankers/models/cohere.mdx create mode 100644 docs/components/rerankers/models/huggingface.mdx create mode 100644 docs/components/rerankers/models/llm_reranker.mdx create mode 100644 docs/components/rerankers/models/sentence_transformer.mdx create mode 100644 docs/components/rerankers/optimization.mdx create mode 100644 docs/components/rerankers/overview.mdx create mode 100644 docs/logo/Favicon copy.png create mode 100644 docs/logo/favicon_old.png create mode 100644 docs/migration/api-changes.mdx create mode 100644 docs/migration/breaking-changes.mdx create mode 100644 docs/migration/v0-to-v1.mdx create mode 100644 docs/open-source/features/metadata-filtering.mdx create mode 100644 docs/open-source/features/reranker-search.mdx create mode 100644 docs/v0x/components/embedders/config.mdx create mode 100644 docs/v0x/components/embedders/models/aws_bedrock.mdx create mode 100644 docs/v0x/components/embedders/models/azure_openai.mdx create mode 100644 docs/v0x/components/embedders/models/google_AI.mdx create mode 100644 docs/v0x/components/embedders/models/huggingface.mdx create mode 100644 docs/v0x/components/embedders/models/langchain.mdx create mode 100644 docs/v0x/components/embedders/models/lmstudio.mdx create mode 100644 docs/v0x/components/embedders/models/ollama.mdx create mode 100644 docs/v0x/components/embedders/models/openai.mdx create mode 100644 docs/v0x/components/embedders/models/together.mdx create mode 100644 docs/v0x/components/embedders/models/vertexai.mdx create mode 100644 docs/v0x/components/embedders/overview.mdx create mode 100644 docs/v0x/components/llms/config.mdx create mode 100644 docs/v0x/components/llms/models/anthropic.mdx create mode 100644 docs/v0x/components/llms/models/aws_bedrock.mdx create mode 100644 docs/v0x/components/llms/models/azure_openai.mdx create mode 100644 docs/v0x/components/llms/models/deepseek.mdx create mode 100644 docs/v0x/components/llms/models/google_AI.mdx create mode 100644 docs/v0x/components/llms/models/groq.mdx create mode 100644 docs/v0x/components/llms/models/langchain.mdx create mode 100644 docs/v0x/components/llms/models/litellm.mdx create mode 100644 docs/v0x/components/llms/models/lmstudio.mdx create mode 100644 docs/v0x/components/llms/models/mistral_AI.mdx create mode 100644 docs/v0x/components/llms/models/ollama.mdx create mode 100644 docs/v0x/components/llms/models/openai.mdx create mode 100644 docs/v0x/components/llms/models/sarvam.mdx create mode 100644 docs/v0x/components/llms/models/together.mdx create mode 100644 docs/v0x/components/llms/models/vllm.mdx create mode 100644 docs/v0x/components/llms/models/xAI.mdx create mode 100644 docs/v0x/components/llms/overview.mdx create mode 100644 docs/v0x/components/vectordbs/config.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/azure.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/baidu.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/chroma.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/databricks.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/elasticsearch.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/faiss.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/langchain.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/milvus.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/mongodb.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/neptune_analytics.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/opensearch.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/pgvector.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/pinecone.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/qdrant.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/redis.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/s3_vectors.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/supabase.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/upstash-vector.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/valkey.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/vectorize.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/vertex_ai.mdx create mode 100644 docs/v0x/components/vectordbs/dbs/weaviate.mdx create mode 100644 docs/v0x/components/vectordbs/overview.mdx create mode 100644 docs/v0x/core-concepts/memory-operations/add.mdx create mode 100644 docs/v0x/core-concepts/memory-operations/delete.mdx create mode 100644 docs/v0x/core-concepts/memory-operations/search.mdx create mode 100644 docs/v0x/core-concepts/memory-operations/update.mdx create mode 100644 docs/v0x/core-concepts/memory-types.mdx create mode 100644 docs/v0x/examples/ai_companion_js.mdx create mode 100644 docs/v0x/examples/aws_example.mdx create mode 100644 docs/v0x/examples/aws_neptune_analytics_hybrid_store.mdx create mode 100644 docs/v0x/examples/chrome-extension.mdx create mode 100644 docs/v0x/examples/collaborative-task-agent.mdx create mode 100644 docs/v0x/examples/customer-support-agent.mdx create mode 100644 docs/v0x/examples/eliza_os.mdx create mode 100644 docs/v0x/examples/email_processing.mdx create mode 100644 docs/v0x/examples/llama-index-mem0.mdx create mode 100644 docs/v0x/examples/llamaindex-multiagent-learning-system.mdx create mode 100644 docs/v0x/examples/mem0-agentic-tool.mdx create mode 100644 docs/v0x/examples/mem0-demo.mdx create mode 100644 docs/v0x/examples/mem0-google-adk-healthcare-assistant.mdx create mode 100644 docs/v0x/examples/mem0-mastra.mdx create mode 100644 docs/v0x/examples/mem0-openai-voice-demo.mdx create mode 100644 docs/v0x/examples/mem0-with-ollama.mdx create mode 100644 docs/v0x/examples/memory-guided-content-writing.mdx create mode 100644 docs/v0x/examples/multimodal-demo.mdx create mode 100644 docs/v0x/examples/openai-inbuilt-tools.mdx create mode 100644 docs/v0x/examples/personal-ai-tutor.mdx create mode 100644 docs/v0x/examples/personal-travel-assistant.mdx create mode 100644 docs/v0x/examples/personalized-deep-research.mdx create mode 100644 docs/v0x/examples/personalized-search-tavily-mem0.mdx create mode 100644 docs/v0x/examples/youtube-assistant.mdx create mode 100644 docs/v0x/faqs.mdx create mode 100644 docs/v0x/images/add_architecture.png create mode 100644 docs/v0x/images/search_architecture.png create mode 100644 docs/v0x/integrations/agentops.mdx create mode 100644 docs/v0x/integrations/agno.mdx create mode 100644 docs/v0x/integrations/autogen.mdx create mode 100644 docs/v0x/integrations/aws-bedrock.mdx create mode 100644 docs/v0x/integrations/crewai.mdx create mode 100644 docs/v0x/integrations/dify.mdx create mode 100644 docs/v0x/integrations/elevenlabs.mdx create mode 100644 docs/v0x/integrations/flowise.mdx create mode 100644 docs/v0x/integrations/google-ai-adk.mdx create mode 100644 docs/v0x/integrations/keywords.mdx create mode 100644 docs/v0x/integrations/langchain-tools.mdx create mode 100644 docs/v0x/integrations/langchain.mdx create mode 100644 docs/v0x/integrations/langgraph.mdx create mode 100644 docs/v0x/integrations/livekit.mdx create mode 100644 docs/v0x/integrations/llama-index.mdx create mode 100644 docs/v0x/integrations/mastra.mdx create mode 100644 docs/v0x/integrations/openai-agents-sdk.mdx create mode 100644 docs/v0x/integrations/pipecat.mdx create mode 100644 docs/v0x/integrations/raycast.mdx create mode 100644 docs/v0x/integrations/vercel-ai-sdk.mdx create mode 100644 docs/v0x/introduction.mdx create mode 100644 docs/v0x/open-source/node-quickstart.mdx create mode 100644 docs/v0x/open-source/overview.mdx create mode 100644 docs/v0x/open-source/python-quickstart.mdx create mode 100644 docs/v0x/quickstart.mdx diff --git a/docs/components/llms/overview.mdx b/docs/components/llms/overview.mdx index c5efdce63..68ae2e4bd 100644 --- a/docs/components/llms/overview.mdx +++ b/docs/components/llms/overview.mdx @@ -28,8 +28,8 @@ See the list of supported LLMs below. - - + + diff --git a/docs/components/rerankers/config.mdx b/docs/components/rerankers/config.mdx new file mode 100644 index 000000000..7c4e46517 --- /dev/null +++ b/docs/components/rerankers/config.mdx @@ -0,0 +1,145 @@ +--- +title: Configuration +icon: "gear" +iconType: "solid" +--- + +## How to define configurations? + +The `reranker` configuration is defined as an object with two main keys: +- `provider`: The name of the reranker provider (e.g., "cohere", "sentence_transformer", "huggingface", "llm_reranker") +- `config`: A nested dictionary containing provider-specific settings + +## Basic Configuration + +Here's how to configure a reranker with Mem0: + +```python +from mem0 import Memory + +config = { + "reranker": { + "provider": "cohere", + "config": { + "api_key": "your-api-key", + "top_n": 10, + "model": "rerank-english-v3.0" + } + } +} + +memory = Memory.from_config(config) +``` + +## Configuration Parameters + +| Parameter | Description | Required | Default | +|-----------|-------------|----------|---------| +| `provider` | Reranker provider name | Yes | - | +| `config` | Provider-specific configuration | Yes | - | + +### Common Config Parameters + +| Parameter | Description | Providers | +|-----------|-------------|-----------| +| `api_key` | API key for the service | Cohere, Hugging Face | +| `model` | Model name to use | All | +| `top_n` | Number of results to return | All | +| `device` | Device to run on (cpu/cuda/mps) | Sentence Transformer, Hugging Face | + +## Provider-Specific Examples + +### Cohere +```python +config = { + "reranker": { + "provider": "cohere", + "config": { + "api_key": "your-cohere-api-key", + "model": "rerank-english-v3.0", + "top_n": 5 + } + } +} +``` + +### Sentence Transformer +```python +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2", + "device": "cpu", + "top_n": 10 + } + } +} +``` + +### Hugging Face +```python +config = { + "reranker": { + "provider": "huggingface", + "config": { + "api_key": "your-hf-token", + "model": "BAAI/bge-reranker-large", + "top_n": 8 + } + } +} +``` + +### LLM Reranker +```python +config = { + "reranker": { + "provider": "llm_reranker", + "config": { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4", + "api_key": "your-openai-key" + } + }, + "top_n": 5 + } + } +} +``` + +## Advanced Configuration + +You can combine rerankers with other components: + +```python +config = { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4", + "api_key": "your-openai-key" + } + }, + "vector_store": { + "provider": "qdrant", + "config": { + "collection_name": "memories", + "host": "localhost", + "port": 6333 + } + }, + "reranker": { + "provider": "cohere", + "config": { + "api_key": "your-cohere-key", + "model": "rerank-english-v3.0", + "top_n": 10 + } + } +} +``` + +For provider-specific configuration details, visit the individual reranker pages. \ No newline at end of file diff --git a/docs/components/rerankers/custom-prompts.mdx b/docs/components/rerankers/custom-prompts.mdx new file mode 100644 index 000000000..4b28ba862 --- /dev/null +++ b/docs/components/rerankers/custom-prompts.mdx @@ -0,0 +1,217 @@ +--- +title: Custom Prompts +icon: "pencil" +iconType: "solid" +--- + +When using LLM rerankers, you can customize the prompts used for ranking to better suit your specific use case and domain. + +## Default Prompt + +The default LLM reranker prompt is designed to be general-purpose: + +``` +Given a query and a list of memory entries, rank the memory entries based on their relevance to the query. +Rate each memory on a scale of 1-10 where 10 is most relevant. + +Query: {query} + +Memory entries: +{memories} + +Provide your ranking as a JSON array with scores for each memory. +``` + +## Custom Prompt Configuration + +You can provide a custom prompt template when configuring the LLM reranker: + +```python +from mem0 import Memory + +custom_prompt = """ +You are an expert at ranking memories for a personal AI assistant. +Given a user query and a list of memory entries, rank each memory based on: +1. Direct relevance to the query +2. Temporal relevance (recent memories may be more important) +3. Emotional significance +4. Actionability + +Query: {query} +User Context: {user_context} + +Memory entries: +{memories} + +Rate each memory from 1-10 and provide reasoning. +Return as JSON: {{"rankings": [{{"index": 0, "score": 8, "reason": "..."}}]}} +""" + +config = { + "reranker": { + "provider": "llm_reranker", + "config": { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4", + "api_key": "your-openai-key" + } + }, + "custom_prompt": custom_prompt, + "top_n": 5 + } + } +} + +memory = Memory.from_config(config) +``` + +## Prompt Variables + +Your custom prompt can use the following variables: + +| Variable | Description | +|----------|-------------| +| `{query}` | The search query | +| `{memories}` | The list of memory entries to rank | +| `{user_id}` | The user ID (if available) | +| `{user_context}` | Additional user context (if provided) | + +## Domain-Specific Examples + +### Customer Support +```python +customer_support_prompt = """ +You are ranking customer support conversation memories. +Prioritize memories that: +- Relate to the current customer issue +- Show previous resolution patterns +- Indicate customer preferences or constraints + +Query: {query} +Customer Context: Previous interactions with this customer + +Memories: +{memories} + +Rank each memory 1-10 based on support relevance. +""" +``` + +### Educational Content +```python +educational_prompt = """ +Rank these learning memories for a student query. +Consider: +- Prerequisite knowledge requirements +- Learning progression and difficulty +- Relevance to current learning objectives + +Student Query: {query} +Learning Context: {user_context} + +Available memories: +{memories} + +Score each memory for educational value (1-10). +""" +``` + +### Personal Assistant +```python +personal_assistant_prompt = """ +Rank personal memories for relevance to the user's query. +Consider: +- Recent vs. historical importance +- Personal preferences and habits +- Contextual relationships between memories + +Query: {query} +Personal context: {user_context} + +Memories to rank: +{memories} + +Provide relevance scores (1-10) with brief explanations. +""" +``` + +## Advanced Prompt Techniques + +### Multi-Criteria Ranking +```python +multi_criteria_prompt = """ +Evaluate memories using multiple criteria: + +1. RELEVANCE (40%): How directly related to the query +2. RECENCY (20%): How recent the memory is +3. IMPORTANCE (25%): Personal or business significance +4. ACTIONABILITY (15%): How useful for next steps + +Query: {query} +Context: {user_context} + +Memories: +{memories} + +For each memory, provide: +- Overall score (1-10) +- Breakdown by criteria +- Final ranking recommendation + +Format: JSON with detailed scoring +""" +``` + +### Contextual Ranking +```python +contextual_prompt = """ +Consider the following context when ranking memories: +- Current user situation: {user_context} +- Time of day: {current_time} +- Recent activities: {recent_activities} + +Query: {query} + +Rank these memories considering both direct relevance and contextual appropriateness: +{memories} + +Provide contextually-aware relevance scores (1-10). +""" +``` + +## Best Practices + +1. **Be Specific**: Clearly define what makes a memory relevant for your use case +2. **Use Examples**: Include examples in your prompt for better model understanding +3. **Structure Output**: Specify the exact JSON format you want returned +4. **Test Iteratively**: Refine your prompt based on actual ranking performance +5. **Consider Token Limits**: Keep prompts concise while being comprehensive + +## Prompt Testing + +You can test different prompts by comparing ranking results: + +```python +# Test multiple prompt variations +prompts = [ + default_prompt, + custom_prompt_v1, + custom_prompt_v2 +] + +for i, prompt in enumerate(prompts): + config["reranker"]["config"]["custom_prompt"] = prompt + memory = Memory.from_config(config) + + results = memory.search("test query", user_id="test_user") + print(f"Prompt {i+1} results: {results}") +``` + +## Common Issues + +- **Too Long**: Keep prompts under token limits for your chosen LLM +- **Too Vague**: Be specific about ranking criteria +- **Inconsistent Format**: Ensure JSON output format is clearly specified +- **Missing Context**: Include relevant variables for your use case \ No newline at end of file diff --git a/docs/components/rerankers/models/cohere.mdx b/docs/components/rerankers/models/cohere.mdx new file mode 100644 index 000000000..06de3976d --- /dev/null +++ b/docs/components/rerankers/models/cohere.mdx @@ -0,0 +1,116 @@ +--- +title: Cohere +--- + +Cohere provides state-of-the-art reranking models that can significantly improve the relevance of search results. Cohere's rerankers are optimized for various languages and use cases. + +## Usage + +To use Cohere's reranker with Mem0: + +```python +import os +from mem0 import Memory + +os.environ["COHERE_API_KEY"] = "your-cohere-api-key" + +config = { + "reranker": { + "provider": "cohere", + "config": { + "api_key": "your-cohere-api-key", # Can also use environment variable + "model": "rerank-english-v3.0", + "top_n": 10 + } + } +} + +memory = Memory.from_config(config) + +# Use memory as usual +memory.add("I love playing basketball", user_id="alice") +memory.add("I enjoy watching movies", user_id="alice") + +# Search will now use Cohere reranking +results = memory.search("What sports does Alice like?", user_id="alice") +``` + +## Configuration + +| Parameter | Description | Default | +|-----------|-------------|---------| +| `api_key` | Cohere API key | Required | +| `model` | Cohere rerank model | `rerank-english-v3.0` | +| `top_n` | Number of results to return | `10` | + +## Available Models + +- `rerank-english-v3.0`: Latest English reranking model +- `rerank-multilingual-v3.0`: Multilingual reranking model +- `rerank-english-v2.0`: Previous English model +- `rerank-multilingual-v2.0`: Previous multilingual model + +## Example with Different Models + +### English Reranker +```python +config = { + "reranker": { + "provider": "cohere", + "config": { + "api_key": "your-cohere-api-key", + "model": "rerank-english-v3.0", + "top_n": 5 + } + } +} +``` + +### Multilingual Reranker +```python +config = { + "reranker": { + "provider": "cohere", + "config": { + "api_key": "your-cohere-api-key", + "model": "rerank-multilingual-v3.0", + "top_n": 8 + } + } +} +``` + +## Environment Variables + +You can set your Cohere API key as an environment variable: + +```bash +export COHERE_API_KEY="your-cohere-api-key" +``` + +Then use the config without specifying the API key: + +```python +config = { + "reranker": { + "provider": "cohere", + "config": { + "model": "rerank-english-v3.0", + "top_n": 10 + } + } +} +``` + +## Getting Your API Key + +1. Sign up at [Cohere](https://cohere.ai/) +2. Navigate to the API keys section in your dashboard +3. Generate a new API key +4. Use this key in your configuration + +## Performance Considerations + +- Cohere rerankers work best with 10-100 candidate documents +- Higher `top_n` values provide more comprehensive reranking but may increase latency +- The v3.0 models generally provide better performance than v2.0 models \ No newline at end of file diff --git a/docs/components/rerankers/models/huggingface.mdx b/docs/components/rerankers/models/huggingface.mdx new file mode 100644 index 000000000..70f32108c --- /dev/null +++ b/docs/components/rerankers/models/huggingface.mdx @@ -0,0 +1,352 @@ +--- +title: Hugging Face Reranker +description: 'Access thousands of reranking models from Hugging Face Hub' +icon: "face-smile" +iconType: "solid" +--- + +## Overview + +The Hugging Face reranker provider gives you access to thousands of reranking models available on the Hugging Face Hub. This includes popular models like BAAI's BGE rerankers and other state-of-the-art cross-encoder models. + +## Configuration + +### Basic Setup + +```python +from mem0 import Memory + +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "BAAI/bge-reranker-base", + "device": "cpu" + } + } +} + +m = Memory.from_config(config) +``` + +### Configuration Parameters + +| Parameter | Type | Default | Description | +|-----------|------|---------|-------------| +| `model` | str | Required | Hugging Face model identifier | +| `device` | str | "cpu" | Device to run model on ("cpu", "cuda", "mps") | +| `batch_size` | int | 32 | Batch size for processing | +| `max_length` | int | 512 | Maximum input sequence length | +| `trust_remote_code` | bool | False | Allow remote code execution | + +### Advanced Configuration + +```python +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "BAAI/bge-reranker-large", + "device": "cuda", + "batch_size": 16, + "max_length": 512, + "trust_remote_code": False, + "model_kwargs": { + "torch_dtype": "float16" + } + } + } +} +``` + +## Popular Models + +### BGE Rerankers (Recommended) + +```python +# Base model - good balance of speed and quality +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "BAAI/bge-reranker-base", + "device": "cuda" + } + } +} + +# Large model - better quality, slower +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "BAAI/bge-reranker-large", + "device": "cuda" + } + } +} + +# v2 models - latest improvements +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "BAAI/bge-reranker-v2-m3", + "device": "cuda" + } + } +} +``` + +### Multilingual Models + +```python +# Multilingual BGE reranker +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "BAAI/bge-reranker-v2-multilingual", + "device": "cuda" + } + } +} +``` + +### Domain-Specific Models + +```python +# For code search +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "microsoft/codebert-base", + "device": "cuda" + } + } +} + +# For biomedical content +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "dmis-lab/biobert-base-cased-v1.1", + "device": "cuda" + } + } +} +``` + +## Usage Examples + +### Basic Usage + +```python +from mem0 import Memory + +m = Memory.from_config(config) + +# Add some memories +m.add("I love hiking in the mountains", user_id="alice") +m.add("Pizza is my favorite food", user_id="alice") +m.add("I enjoy reading science fiction books", user_id="alice") + +# Search with reranking +results = m.search( + "What outdoor activities do I enjoy?", + user_id="alice", + rerank=True +) + +for result in results["results"]: + print(f"Memory: {result['memory']}") + print(f"Score: {result['score']:.3f}") +``` + +### Batch Processing + +```python +# Process multiple queries efficiently +queries = [ + "What are my hobbies?", + "What food do I like?", + "What books interest me?" +] + +results = [] +for query in queries: + result = m.search(query, user_id="alice", rerank=True) + results.append(result) +``` + +## Performance Optimization + +### GPU Acceleration + +```python +# Use GPU for better performance +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "BAAI/bge-reranker-base", + "device": "cuda", + "batch_size": 64, # Increase batch size for GPU + } + } +} +``` + +### Memory Optimization + +```python +# For limited memory environments +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "BAAI/bge-reranker-base", + "device": "cpu", + "batch_size": 8, # Smaller batch size + "max_length": 256, # Shorter sequences + "model_kwargs": { + "torch_dtype": "float16" # Half precision + } + } + } +} +``` + +## Model Comparison + +| Model | Size | Quality | Speed | Memory | Best For | +|-------|------|---------|-------|---------|----------| +| bge-reranker-base | 278M | Good | Fast | Low | General use | +| bge-reranker-large | 560M | Better | Medium | Medium | High quality needs | +| bge-reranker-v2-m3 | 568M | Best | Medium | Medium | Latest improvements | +| bge-reranker-v2-multilingual | 568M | Good | Medium | Medium | Multiple languages | + +## Error Handling + +```python +try: + results = m.search( + "test query", + user_id="alice", + rerank=True + ) +except Exception as e: + print(f"Reranking failed: {e}") + # Fall back to vector search only + results = m.search( + "test query", + user_id="alice", + rerank=False + ) +``` + +## Custom Models + +### Using Private Models + +```python +# Use a private model from Hugging Face +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "your-org/custom-reranker", + "device": "cuda", + "use_auth_token": "your-hf-token" + } + } +} +``` + +### Local Model Path + +```python +# Use a locally downloaded model +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "/path/to/local/model", + "device": "cuda" + } + } +} +``` + +## Best Practices + +1. **Choose the Right Model**: Balance quality vs speed based on your needs +2. **Use GPU**: Significantly faster than CPU for larger models +3. **Optimize Batch Size**: Tune based on your hardware capabilities +4. **Monitor Memory**: Watch GPU/CPU memory usage with large models +5. **Cache Models**: Download once and reuse to avoid repeated downloads + +## Troubleshooting + +### Common Issues + +**Out of Memory Error** +```python +# Reduce batch size and sequence length +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "BAAI/bge-reranker-base", + "batch_size": 4, + "max_length": 256 + } + } +} +``` + +**Model Download Issues** +```python +# Set cache directory +import os +os.environ["TRANSFORMERS_CACHE"] = "/path/to/cache" + +# Or use offline mode +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "BAAI/bge-reranker-base", + "local_files_only": True + } + } +} +``` + +**CUDA Not Available** +```python +import torch + +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "BAAI/bge-reranker-base", + "device": "cuda" if torch.cuda.is_available() else "cpu" + } + } +} +``` + +## Next Steps + + + + Learn about reranking concepts + + + Detailed configuration options + + \ No newline at end of file diff --git a/docs/components/rerankers/models/llm_reranker.mdx b/docs/components/rerankers/models/llm_reranker.mdx new file mode 100644 index 000000000..4724290c2 --- /dev/null +++ b/docs/components/rerankers/models/llm_reranker.mdx @@ -0,0 +1,491 @@ +--- +title: LLM Reranker +description: 'Use any language model as a reranker with custom prompts' +icon: "robot" +iconType: "solid" +--- + +## Overview + +The LLM reranker allows you to use any supported language model as a reranker. This approach uses prompts to instruct the LLM to score and rank memories based on their relevance to the query. While slower than specialized rerankers, it offers maximum flexibility and can be fine-tuned with custom prompts. + +## Configuration + +### Basic Setup + +```python +from mem0 import Memory + +config = { + "reranker": { + "provider": "llm_reranker", + "config": { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4", + "api_key": "your-openai-api-key" + } + } + } + } +} + +m = Memory.from_config(config) +``` + +### Configuration Parameters + +| Parameter | Type | Default | Description | +|-----------|------|---------|-------------| +| `llm` | dict | Required | LLM configuration object | +| `top_k` | int | 10 | Number of results to rerank | +| `temperature` | float | 0.0 | LLM temperature for consistency | +| `custom_prompt` | str | None | Custom reranking prompt | +| `score_range` | tuple | (0, 10) | Score range for relevance | + +### Advanced Configuration + +```python +config = { + "reranker": { + "provider": "llm_reranker", + "config": { + "llm": { + "provider": "anthropic", + "config": { + "model": "claude-3-sonnet-20240229", + "api_key": "your-anthropic-api-key" + } + }, + "top_k": 15, + "temperature": 0.0, + "score_range": (1, 5), + "custom_prompt": """ + Rate the relevance of each memory to the query on a scale of 1-5. + Consider semantic similarity, context, and practical utility. + Only provide the numeric score. + """ + } + } +} +``` + +## Supported LLM Providers + +### OpenAI + +```python +config = { + "reranker": { + "provider": "llm_reranker", + "config": { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4", + "api_key": "your-openai-api-key", + "temperature": 0.0 + } + } + } + } +} +``` + +### Anthropic + +```python +config = { + "reranker": { + "provider": "llm_reranker", + "config": { + "llm": { + "provider": "anthropic", + "config": { + "model": "claude-3-sonnet-20240229", + "api_key": "your-anthropic-api-key" + } + } + } + } +} +``` + +### Ollama (Local) + +```python +config = { + "reranker": { + "provider": "llm_reranker", + "config": { + "llm": { + "provider": "ollama", + "config": { + "model": "llama2", + "ollama_base_url": "http://localhost:11434" + } + } + } + } +} +``` + +### Azure OpenAI + +```python +config = { + "reranker": { + "provider": "llm_reranker", + "config": { + "llm": { + "provider": "azure_openai", + "config": { + "model": "gpt-4", + "api_key": "your-azure-api-key", + "azure_endpoint": "https://your-resource.openai.azure.com/", + "azure_deployment": "gpt-4-deployment" + } + } + } + } +} +``` + +## Custom Prompts + +### Default Prompt Behavior + +The default prompt asks the LLM to score relevance on a 0-10 scale: + +``` +Given a query and a memory, rate how relevant the memory is to answering the query. +Score from 0 (completely irrelevant) to 10 (perfectly relevant). +Only provide the numeric score. + +Query: {query} +Memory: {memory} +Score: +``` + +### Custom Prompt Examples + +#### Domain-Specific Scoring + +```python +custom_prompt = """ +You are a medical information specialist. Rate how relevant each memory is for answering the medical query. +Consider clinical accuracy, specificity, and practical applicability. +Rate from 1-10 where: +- 1-3: Irrelevant or potentially harmful +- 4-6: Somewhat relevant but incomplete +- 7-8: Relevant and helpful +- 9-10: Highly relevant and clinically useful + +Query: {query} +Memory: {memory} +Score: +""" + +config = { + "reranker": { + "provider": "llm_reranker", + "config": { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4", + "api_key": "your-api-key" + } + }, + "custom_prompt": custom_prompt + } + } +} +``` + +#### Contextual Relevance + +```python +contextual_prompt = """ +Rate how well this memory answers the specific question asked. +Consider: +- Direct relevance to the question +- Completeness of information +- Recency and accuracy +- Practical usefulness + +Rate 1-5: +1 = Not relevant +2 = Slightly relevant +3 = Moderately relevant +4 = Very relevant +5 = Perfectly answers the question + +Query: {query} +Memory: {memory} +Score: +""" +``` + +#### Conversational Context + +```python +conversation_prompt = """ +You are helping evaluate which memories are most useful for a conversational AI assistant. +Rate how helpful this memory would be for generating a relevant response. + +Consider: +- Direct relevance to user's intent +- Emotional appropriateness +- Factual accuracy +- Conversation flow + +Rate 0-10: +Query: {query} +Memory: {memory} +Score: +""" +``` + +## Usage Examples + +### Basic Usage + +```python +from mem0 import Memory + +m = Memory.from_config(config) + +# Add memories +m.add("I'm allergic to peanuts", user_id="alice") +m.add("I love Italian food", user_id="alice") +m.add("I'm vegetarian", user_id="alice") + +# Search with LLM reranking +results = m.search( + "What foods should I avoid?", + user_id="alice", + rerank=True +) + +for result in results["results"]: + print(f"Memory: {result['memory']}") + print(f"LLM Score: {result['score']:.2f}") +``` + +### Batch Processing with Error Handling + +```python +def safe_llm_rerank_search(query, user_id, max_retries=3): + for attempt in range(max_retries): + try: + return m.search(query, user_id=user_id, rerank=True) + except Exception as e: + print(f"Attempt {attempt + 1} failed: {e}") + if attempt == max_retries - 1: + # Fall back to vector search + return m.search(query, user_id=user_id, rerank=False) + +# Use the safe function +results = safe_llm_rerank_search("What are my preferences?", "alice") +``` + +## Performance Considerations + +### Speed vs Quality Trade-offs + +| Model Type | Speed | Quality | Cost | Best For | +|------------|-------|---------|------|----------| +| GPT-3.5 Turbo | Fast | Good | Low | High-volume applications | +| GPT-4 | Medium | Excellent | Medium | Quality-critical applications | +| Claude 3 Sonnet | Medium | Excellent | Medium | Balanced performance | +| Ollama Local | Variable | Good | Free | Privacy-sensitive applications | + +### Optimization Strategies + +```python +# Fast configuration for high-volume use +fast_config = { + "reranker": { + "provider": "llm_reranker", + "config": { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-3.5-turbo", + "api_key": "your-api-key" + } + }, + "top_k": 5, # Limit candidates + "temperature": 0.0 + } + } +} + +# High-quality configuration +quality_config = { + "reranker": { + "provider": "llm_reranker", + "config": { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4", + "api_key": "your-api-key" + } + }, + "top_k": 15, + "temperature": 0.0 + } + } +} +``` + +## Advanced Use Cases + +### Multi-Step Reasoning + +```python +reasoning_prompt = """ +Evaluate this memory's relevance using multi-step reasoning: + +1. What is the main intent of the query? +2. What key information does the memory contain? +3. How directly does the memory address the query? +4. What additional context might be needed? + +Based on this analysis, rate relevance 1-10: + +Query: {query} +Memory: {memory} + +Analysis: +Step 1 (Intent): +Step 2 (Information): +Step 3 (Directness): +Step 4 (Context): +Final Score: +""" +``` + +### Comparative Ranking + +```python +comparative_prompt = """ +You will see a query and multiple memories. Rank them in order of relevance. +Consider which memories best answer the question and would be most helpful. + +Query: {query} + +Memories to rank: +{memories} + +Provide scores 1-10 for each memory, considering their relative usefulness. +""" +``` + +### Emotional Intelligence + +```python +emotional_prompt = """ +Consider both factual relevance and emotional appropriateness. +Rate how suitable this memory is for responding to the user's query. + +Factors to consider: +- Factual accuracy and relevance +- Emotional tone and sensitivity +- User's likely emotional state +- Appropriateness of response + +Query: {query} +Memory: {memory} +Emotional Context: {context} +Score (1-10): +""" +``` + +## Error Handling and Fallbacks + +```python +class RobustLLMReranker: + def __init__(self, primary_config, fallback_config=None): + self.primary = Memory.from_config(primary_config) + self.fallback = Memory.from_config(fallback_config) if fallback_config else None + + def search(self, query, user_id, max_retries=2): + # Try primary LLM reranker + for attempt in range(max_retries): + try: + return self.primary.search(query, user_id=user_id, rerank=True) + except Exception as e: + print(f"Primary reranker attempt {attempt + 1} failed: {e}") + + # Try fallback reranker + if self.fallback: + try: + return self.fallback.search(query, user_id=user_id, rerank=True) + except Exception as e: + print(f"Fallback reranker failed: {e}") + + # Final fallback: vector search only + return self.primary.search(query, user_id=user_id, rerank=False) + +# Usage +primary_config = { + "reranker": { + "provider": "llm_reranker", + "config": {"llm": {"provider": "openai", "config": {"model": "gpt-4"}}} + } +} + +fallback_config = { + "reranker": { + "provider": "llm_reranker", + "config": {"llm": {"provider": "openai", "config": {"model": "gpt-3.5-turbo"}}} + } +} + +reranker = RobustLLMReranker(primary_config, fallback_config) +results = reranker.search("What are my preferences?", "alice") +``` + +## Best Practices + +1. **Use Specific Prompts**: Tailor prompts to your domain and use case +2. **Set Temperature to 0**: Ensure consistent scoring across runs +3. **Limit Top-K**: Don't rerank too many candidates to control costs +4. **Implement Fallbacks**: Always have a backup plan for API failures +5. **Monitor Costs**: Track API usage, especially with expensive models +6. **Cache Results**: Consider caching reranking results for repeated queries +7. **Test Prompts**: Experiment with different prompts to find what works best + +## Troubleshooting + +### Common Issues + +**Inconsistent Scores** +- Set temperature to 0.0 +- Use more specific prompts +- Consider using multiple calls and averaging + +**API Rate Limits** +- Implement exponential backoff +- Use cheaper models for high-volume scenarios +- Add retry logic with delays + +**Poor Ranking Quality** +- Refine your custom prompt +- Try different LLM models +- Add examples to your prompt + +## Next Steps + + + + Learn to craft effective reranking prompts + + + Optimize LLM reranker performance + + \ No newline at end of file diff --git a/docs/components/rerankers/models/sentence_transformer.mdx b/docs/components/rerankers/models/sentence_transformer.mdx new file mode 100644 index 000000000..55f428658 --- /dev/null +++ b/docs/components/rerankers/models/sentence_transformer.mdx @@ -0,0 +1,162 @@ +--- +title: Sentence Transformer +--- + +Sentence Transformer rerankers use cross-encoder models that are specifically designed for ranking tasks. These models can run locally and provide good reranking performance without external API calls. + +## Usage + +To use Sentence Transformer reranker with Mem0: + +```python +from mem0 import Memory + +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2", + "device": "cpu", + "top_n": 10 + } + } +} + +memory = Memory.from_config(config) + +# Use memory as usual +memory.add("I love playing basketball", user_id="alice") +memory.add("I enjoy watching movies", user_id="alice") + +# Search will now use Sentence Transformer reranking +results = memory.search("What sports does Alice like?", user_id="alice") +``` + +## Configuration + +| Parameter | Description | Default | +|-----------|-------------|---------| +| `model` | Sentence Transformer cross-encoder model | `cross-encoder/ms-marco-MiniLM-L-6-v2` | +| `device` | Device to run on (`cpu`, `cuda`, `mps`) | `cpu` | +| `top_n` | Number of results to return | `10` | + +## Popular Models + +### Lightweight Models +- `cross-encoder/ms-marco-MiniLM-L-6-v2`: Fast and efficient +- `cross-encoder/ms-marco-MiniLM-L-4-v2`: Even faster, slightly lower accuracy +- `cross-encoder/ms-marco-MiniLM-L-2-v2`: Fastest, good for real-time applications + +### High-Performance Models +- `cross-encoder/ms-marco-electra-base`: Better accuracy, larger model +- `ms-marco-MiniLM-L-12-v2`: Balanced performance and speed +- `cross-encoder/qnli-electra-base`: Good for question-answering tasks + +## Device Configuration + +### CPU Usage +```python +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2", + "device": "cpu", + "top_n": 10 + } + } +} +``` + +### GPU Usage (CUDA) +```python +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-electra-base", + "device": "cuda", + "top_n": 15 + } + } +} +``` + +### Apple Silicon (MPS) +```python +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2", + "device": "mps", + "top_n": 10 + } + } +} +``` + +## Installation + +The sentence-transformers library is required: + +```bash +pip install sentence-transformers +``` + +For GPU support with CUDA: +```bash +pip install sentence-transformers torch +``` + +## Performance Optimization + +### Model Selection +- Use MiniLM models for faster inference +- Use larger models (electra-base) for better accuracy +- Consider the trade-off between speed and quality + +### Device Optimization +- Use GPU (`cuda` or `mps`) for larger models +- CPU is sufficient for MiniLM models +- Batch processing improves GPU utilization + +### Memory Considerations +```python +# For memory-constrained environments +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-MiniLM-L-2-v2", # Smallest model + "device": "cpu", + "top_n": 5 # Fewer results to process + } + } +} +``` + +## Custom Models + +You can use any Sentence Transformer cross-encoder model: + +```python +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "your-custom-model-name", + "device": "cpu", + "top_n": 10 + } + } +} +``` + +## Advantages + +- **Local Processing**: No external API calls required +- **Privacy**: Data stays on your infrastructure +- **Cost Effective**: No per-request charges +- **Fast**: Especially with GPU acceleration +- **Customizable**: Can fine-tune on your specific data \ No newline at end of file diff --git a/docs/components/rerankers/optimization.mdx b/docs/components/rerankers/optimization.mdx new file mode 100644 index 000000000..c08bb9383 --- /dev/null +++ b/docs/components/rerankers/optimization.mdx @@ -0,0 +1,312 @@ +--- +title: Performance Optimization +icon: "bolt" +iconType: "solid" +--- + +Optimizing reranker performance is crucial for maintaining fast search response times while improving result quality. This guide covers best practices for different reranker types. + +## General Optimization Principles + +### Candidate Set Size +The number of candidates sent to the reranker significantly impacts performance: + +```python +# Optimal candidate sizes for different rerankers +config_map = { + "cohere": {"initial_candidates": 100, "top_n": 10}, + "sentence_transformer": {"initial_candidates": 50, "top_n": 10}, + "huggingface": {"initial_candidates": 30, "top_n": 5}, + "llm_reranker": {"initial_candidates": 20, "top_n": 5} +} +``` + +### Batching Strategy +Process multiple queries efficiently: + +```python +# Configure for batch processing +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2", + "batch_size": 16, # Process multiple candidates at once + "top_n": 10 + } + } +} +``` + +## Provider-Specific Optimizations + +### Cohere Optimization + +```python +# Optimized Cohere configuration +config = { + "reranker": { + "provider": "cohere", + "config": { + "model": "rerank-english-v3.0", + "top_n": 10, + "max_chunks_per_doc": 10, # Limit chunk processing + "return_documents": False # Reduce response size + } + } +} +``` + +**Best Practices:** +- Use v3.0 models for better speed/accuracy balance +- Limit candidates to 100 or fewer +- Cache API responses when possible +- Monitor API rate limits + +### Sentence Transformer Optimization + +```python +# Performance-optimized configuration +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2", + "device": "cuda", # Use GPU when available + "batch_size": 32, + "top_n": 10, + "max_length": 512 # Limit input length + } + } +} +``` + +**Device Optimization:** +```python +import torch + +# Auto-detect best device +device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu" + +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "device": device, + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2" + } + } +} +``` + +### Hugging Face Optimization + +```python +# Optimized for Hugging Face models +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "BAAI/bge-reranker-base", + "use_fp16": True, # Half precision for speed + "max_length": 512, + "batch_size": 8, + "top_n": 10 + } + } +} +``` + +### LLM Reranker Optimization + +```python +# Optimized LLM reranker configuration +config = { + "reranker": { + "provider": "llm_reranker", + "config": { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-3.5-turbo", # Faster than gpt-4 + "temperature": 0, # Deterministic results + "max_tokens": 500 # Limit response length + } + }, + "batch_ranking": True, # Rank multiple at once + "top_n": 5, # Fewer results for faster processing + "timeout": 10 # Request timeout + } + } +} +``` + +## Performance Monitoring + +### Latency Tracking +```python +import time +from mem0 import Memory + +def measure_reranker_performance(config, queries, user_id): + memory = Memory.from_config(config) + + latencies = [] + for query in queries: + start_time = time.time() + results = memory.search(query, user_id=user_id) + latency = time.time() - start_time + latencies.append(latency) + + return { + "avg_latency": sum(latencies) / len(latencies), + "max_latency": max(latencies), + "min_latency": min(latencies) + } +``` + +### Memory Usage Monitoring +```python +import psutil +import os + +def monitor_memory_usage(): + process = psutil.Process(os.getpid()) + return { + "memory_mb": process.memory_info().rss / 1024 / 1024, + "memory_percent": process.memory_percent() + } +``` + +## Caching Strategies + +### Result Caching +```python +from functools import lru_cache +import hashlib + +class CachedReranker: + def __init__(self, config): + self.memory = Memory.from_config(config) + self.cache_size = 1000 + + @lru_cache(maxsize=1000) + def search_cached(self, query_hash, user_id): + return self.memory.search(query, user_id=user_id) + + def search(self, query, user_id): + query_hash = hashlib.md5(f"{query}_{user_id}".encode()).hexdigest() + return self.search_cached(query_hash, user_id) +``` + +### Model Caching +```python +# Pre-load models to avoid initialization overhead +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2", + "cache_folder": "/path/to/model/cache", + "device": "cuda" + } + } +} +``` + +## Parallel Processing + +### Async Configuration +```python +import asyncio +from mem0 import Memory + +async def parallel_search(config, queries, user_id): + memory = Memory.from_config(config) + + # Process multiple queries concurrently + tasks = [ + memory.search_async(query, user_id=user_id) + for query in queries + ] + + results = await asyncio.gather(*tasks) + return results +``` + +## Hardware Optimization + +### GPU Configuration +```python +# Optimize for GPU usage +import torch + +if torch.cuda.is_available(): + torch.cuda.set_per_process_memory_fraction(0.8) # Reserve GPU memory + +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "device": "cuda", + "model": "cross-encoder/ms-marco-electra-base", + "batch_size": 64, # Larger batch for GPU + "fp16": True # Half precision + } + } +} +``` + +### CPU Optimization +```python +import torch + +# Optimize CPU threading +torch.set_num_threads(4) # Adjust based on your CPU + +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "device": "cpu", + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2", + "num_workers": 4 # Parallel processing + } + } +} +``` + +## Benchmarking Different Configurations + +```python +def benchmark_rerankers(): + configs = [ + {"provider": "cohere", "model": "rerank-english-v3.0"}, + {"provider": "sentence_transformer", "model": "cross-encoder/ms-marco-MiniLM-L-6-v2"}, + {"provider": "huggingface", "model": "BAAI/bge-reranker-base"} + ] + + test_queries = ["sample query 1", "sample query 2", "sample query 3"] + + results = {} + for config in configs: + provider = config["provider"] + performance = measure_reranker_performance( + {"reranker": {"provider": provider, "config": config}}, + test_queries, + "test_user" + ) + results[provider] = performance + + return results +``` + +## Production Best Practices + +1. **Model Selection**: Choose the right balance of speed vs. accuracy +2. **Resource Allocation**: Monitor CPU/GPU usage and memory consumption +3. **Error Handling**: Implement fallbacks for reranker failures +4. **Load Balancing**: Distribute reranking load across multiple instances +5. **Monitoring**: Track latency, throughput, and error rates +6. **Caching**: Cache frequent queries and model predictions +7. **Batch Processing**: Group similar queries for efficient processing \ No newline at end of file diff --git a/docs/components/rerankers/overview.mdx b/docs/components/rerankers/overview.mdx new file mode 100644 index 000000000..4c90bc6d9 --- /dev/null +++ b/docs/components/rerankers/overview.mdx @@ -0,0 +1,52 @@ +--- +title: Overview +icon: "info" +iconType: "solid" +--- + +Rerankers enhance the quality of search results by re-ordering the initial retrieval results using more sophisticated scoring mechanisms. They act as a secondary ranking layer that can significantly improve the relevance of retrieved memories. + +## How Rerankers Work + +1. **Initial Retrieval**: Vector search returns candidate memories based on semantic similarity +2. **Reranking**: The reranker evaluates and re-scores these candidates using more complex criteria +3. **Final Results**: Returns the top-k memories with improved relevance ordering + +## Benefits + +- **Improved Precision**: Better ranking of relevant memories +- **Context Awareness**: More sophisticated understanding of query-memory relationships +- **Performance**: Can improve results without changing the underlying vector store + +## Supported Rerankers + +Mem0 supports several reranker models: + + + + + + + + +## Usage + +Rerankers are configured as part of the memory configuration: + +```python +from mem0 import Memory + +config = { + "reranker": { + "provider": "cohere", + "config": { + "api_key": "your-api-key", + "top_n": 10 + } + } +} + +memory = Memory.from_config(config) +``` + +For detailed configuration options, see the [Config](./config) page. \ No newline at end of file diff --git a/docs/docs.json b/docs/docs.json index 0eee761fe..73d20809b 100644 --- a/docs/docs.json +++ b/docs/docs.json @@ -2,194 +2,389 @@ "$schema": "https://mintlify.com/docs.json", "name": "Mem0", "description": "Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users.", - "theme": "maple", + "theme": "aspen", "colors": { - "primary": "#6c60f0", - "light": "#E6FFA2", - "dark": "#a3df02" + "primary": "#2553eb", + "light": "#6084fa", + "dark": "#2553eb" }, "favicon": "/logo/favicon.png", "navigation": { - "anchors": [ + "versions": [ { - "anchor": "Documentation", - "icon": "book-open", - "tabs": [ + "version": "v1.0 Beta", + "anchors": [ { - "tab": "Documentation", - "groups": [ + "anchor": "Documentation", + "icon": "book-open", + "tabs": [ { - "group": "Getting Started", - "icon": "rocket", - "pages": [ - "introduction", - "quickstart", - "faqs" - ] - }, - { - "group": "Core Concepts", - "icon": "brain", - "pages": [ - "core-concepts/memory-types", + "tab": "Documentation", + "groups": [ { - "group": "Memory Operations", - "icon": "gear", + "group": "Getting Started", + "icon": "rocket", "pages": [ - "core-concepts/memory-operations/add", - "core-concepts/memory-operations/search", - "core-concepts/memory-operations/update", - "core-concepts/memory-operations/delete" - ] - } - ] - }, - { - "group": "Platform", - "icon": "globe", - "pages": [ - "platform/overview", - "platform/quickstart", - "platform/advanced-memory-operations", - { - "group": "Features", - "icon": "star", - "pages": [ - "platform/features/platform-overview", - "platform/features/contextual-add", - "platform/features/async-client", - "platform/features/graph-memory", - "platform/features/advanced-retrieval", - "platform/features/criteria-retrieval", - "platform/features/multimodal-support", - "platform/features/selective-memory", - "platform/features/custom-categories", - "platform/features/custom-instructions", - "platform/features/direct-import", - "platform/features/memory-export", - "platform/features/timestamp", - "platform/features/expiration-date", - "platform/features/webhooks", - "platform/features/feedback-mechanism", - "platform/features/group-chat" - ] - } - ] - }, - { - "group": "Open Source", - "icon": "code-branch", - "pages": [ - "open-source/overview", - "open-source/python-quickstart", - "open-source/node-quickstart", - { - "group": "Features", - "icon": "star", - "pages": [ - "open-source/features/overview", - "open-source/features/async-memory", - "open-source/features/openai_compatibility", - "open-source/features/custom-fact-extraction-prompt", - "open-source/features/custom-update-memory-prompt", - "open-source/features/multimodal-support", - "open-source/features/rest-api" + "introduction", + "quickstart", + "faqs" ] }, { - "group": "Graph Memory", - "icon": "spider-web", - "pages": [ - "open-source/graph_memory/overview", - "open-source/graph_memory/features" - ] - }, - { - "group": "LLMs", + "group": "Core Concepts", "icon": "brain", "pages": [ - "components/llms/overview", - "components/llms/config", + "core-concepts/memory-types", { - "group": "Supported LLMs", - "icon": "list", + "group": "Memory Operations", + "icon": "gear", "pages": [ - "components/llms/models/openai", - "components/llms/models/anthropic", - "components/llms/models/azure_openai", - "components/llms/models/ollama", - "components/llms/models/together", - "components/llms/models/groq", - "components/llms/models/litellm", - "components/llms/models/mistral_AI", - "components/llms/models/google_AI", - "components/llms/models/aws_bedrock", - "components/llms/models/deepseek", - "components/llms/models/xAI", - "components/llms/models/sarvam", - "components/llms/models/lmstudio", - "components/llms/models/langchain", - "components/llms/models/vllm" + "core-concepts/memory-operations/add", + "core-concepts/memory-operations/search", + "core-concepts/memory-operations/update", + "core-concepts/memory-operations/delete" ] } ] }, { - "group": "Vector Databases", - "icon": "database", + "group": "Platform", + "icon": "globe", "pages": [ - "components/vectordbs/overview", - "components/vectordbs/config", + "platform/overview", + "platform/quickstart", + "platform/advanced-memory-operations", { - "group": "Supported Vector Databases", - "icon": "server", + "group": "Features", + "icon": "star", "pages": [ - "components/vectordbs/dbs/qdrant", - "components/vectordbs/dbs/chroma", - "components/vectordbs/dbs/pgvector", - "components/vectordbs/dbs/milvus", - "components/vectordbs/dbs/pinecone", - "components/vectordbs/dbs/mongodb", - "components/vectordbs/dbs/azure", - "components/vectordbs/dbs/redis", - "components/vectordbs/dbs/valkey", - "components/vectordbs/dbs/elasticsearch", - "components/vectordbs/dbs/opensearch", - "components/vectordbs/dbs/supabase", - "components/vectordbs/dbs/upstash-vector", - "components/vectordbs/dbs/vectorize", - "components/vectordbs/dbs/vertex_ai", - "components/vectordbs/dbs/weaviate", - "components/vectordbs/dbs/faiss", - "components/vectordbs/dbs/langchain", - "components/vectordbs/dbs/baidu", - "components/vectordbs/dbs/s3_vectors", - "components/vectordbs/dbs/databricks", - "components/vectordbs/dbs/neptune_analytics" + "platform/features/platform-overview", + "platform/features/contextual-add", + "platform/features/async-client", + "platform/features/graph-memory", + "platform/features/advanced-retrieval", + "platform/features/criteria-retrieval", + "platform/features/multimodal-support", + "platform/features/selective-memory", + "platform/features/custom-categories", + "platform/features/custom-instructions", + "platform/features/direct-import", + "platform/features/memory-export", + "platform/features/timestamp", + "platform/features/expiration-date", + "platform/features/webhooks", + "platform/features/feedback-mechanism", + "platform/features/group-chat" ] } ] }, { - "group": "Embedding Models", - "icon": "layer-group", + "group": "Open Source", + "icon": "code-branch", "pages": [ - "components/embedders/overview", - "components/embedders/config", + "open-source/overview", + "open-source/python-quickstart", + "open-source/node-quickstart", { - "group": "Supported Embedding Models", - "icon": "list", + "group": "Features", + "icon": "star", "pages": [ - "components/embedders/models/openai", - "components/embedders/models/azure_openai", - "components/embedders/models/ollama", - "components/embedders/models/huggingface", - "components/embedders/models/vertexai", - "components/embedders/models/google_AI", - "components/embedders/models/lmstudio", - "components/embedders/models/together", - "components/embedders/models/langchain", - "components/embedders/models/aws_bedrock" + "open-source/features/overview", + "open-source/features/async-memory", + "open-source/features/openai_compatibility", + "open-source/features/custom-fact-extraction-prompt", + "open-source/features/custom-update-memory-prompt", + "open-source/features/multimodal-support", + "open-source/features/rest-api", + "open-source/features/metadata-filtering", + "open-source/features/reranker-search" + ] + }, + { + "group": "Graph Memory", + "icon": "spider-web", + "pages": [ + "open-source/graph_memory/overview", + "open-source/graph_memory/features" + ] + }, + { + "group": "LLMs", + "icon": "brain", + "pages": [ + "components/llms/overview", + "components/llms/config", + { + "group": "Supported LLMs", + "icon": "list", + "pages": [ + "components/llms/models/openai", + "components/llms/models/anthropic", + "components/llms/models/azure_openai", + "components/llms/models/ollama", + "components/llms/models/together", + "components/llms/models/groq", + "components/llms/models/litellm", + "components/llms/models/mistral_AI", + "components/llms/models/google_AI", + "components/llms/models/aws_bedrock", + "components/llms/models/deepseek", + "components/llms/models/xAI", + "components/llms/models/sarvam", + "components/llms/models/lmstudio", + "components/llms/models/langchain", + "components/llms/models/vllm" + ] + } + ] + }, + { + "group": "Vector Databases", + "icon": "database", + "pages": [ + "components/vectordbs/overview", + "components/vectordbs/config", + { + "group": "Supported Vector Databases", + "icon": "server", + "pages": [ + "components/vectordbs/dbs/qdrant", + "components/vectordbs/dbs/chroma", + "components/vectordbs/dbs/pgvector", + "components/vectordbs/dbs/milvus", + "components/vectordbs/dbs/pinecone", + "components/vectordbs/dbs/mongodb", + "components/vectordbs/dbs/azure", + "components/vectordbs/dbs/redis", + "components/vectordbs/dbs/valkey", + "components/vectordbs/dbs/elasticsearch", + "components/vectordbs/dbs/opensearch", + "components/vectordbs/dbs/supabase", + "components/vectordbs/dbs/upstash-vector", + "components/vectordbs/dbs/vectorize", + "components/vectordbs/dbs/vertex_ai", + "components/vectordbs/dbs/weaviate", + "components/vectordbs/dbs/faiss", + "components/vectordbs/dbs/langchain", + "components/vectordbs/dbs/baidu", + "components/vectordbs/dbs/s3_vectors", + "components/vectordbs/dbs/databricks", + "components/vectordbs/dbs/neptune_analytics" + ] + } + ] + }, + { + "group": "Embedding Models", + "icon": "layer-group", + "pages": [ + "components/embedders/overview", + "components/embedders/config", + { + "group": "Supported Embedding Models", + "icon": "list", + "pages": [ + "components/embedders/models/openai", + "components/embedders/models/azure_openai", + "components/embedders/models/ollama", + "components/embedders/models/huggingface", + "components/embedders/models/vertexai", + "components/embedders/models/google_AI", + "components/embedders/models/lmstudio", + "components/embedders/models/together", + "components/embedders/models/langchain", + "components/embedders/models/aws_bedrock" + ] + } + ] + }, + { + "group": "Rerankers (New in v1.0)", + "icon": "sort", + "pages": [ + "components/rerankers/overview", + "components/rerankers/config", + { + "group": "Supported Rerankers", + "icon": "list", + "pages": [ + "components/rerankers/models/cohere", + "components/rerankers/models/sentence_transformer", + "components/rerankers/models/huggingface", + "components/rerankers/models/llm_reranker" + ] + } + ] + } + ] + }, + { + "group": "Migration Guide", + "icon": "arrow-right", + "pages": [ + "migration/v0-to-v1", + "migration/breaking-changes", + "migration/api-changes" + ] + }, + { + "group": "OpenMemory", + "icon": "square-terminal", + "pages": [ + "openmemory/overview", + "openmemory/quickstart", + "openmemory/integrations" + ] + }, + { + "group": "Contribution", + "icon": "handshake", + "pages": [ + "contributing/development", + "contributing/documentation" + ] + } + ] + }, + { + "tab": "Examples", + "groups": [ + { + "group": "💡 Examples", + "icon": "lightbulb", + "pages": [ + "examples", + "examples/aws_example", + "examples/aws_neptune_analytics_hybrid_store", + "examples/mem0-demo", + "examples/ai_companion_js", + "examples/collaborative-task-agent", + "examples/llamaindex-multiagent-learning-system", + "examples/personalized-search-tavily-mem0", + "examples/eliza_os", + "examples/mem0-mastra", + "examples/mem0-with-ollama", + "examples/personal-ai-tutor", + "examples/customer-support-agent", + "examples/personal-travel-assistant", + "examples/llama-index-mem0", + "examples/chrome-extension", + "examples/memory-guided-content-writing", + "examples/multimodal-demo", + "examples/personalized-deep-research", + "examples/mem0-agentic-tool", + "examples/openai-inbuilt-tools", + "examples/mem0-openai-voice-demo", + "examples/mem0-google-adk-healthcare-assistant", + "examples/email_processing", + "examples/youtube-assistant" + ] + } + ] + }, + { + "tab": "Integrations", + "groups": [ + { + "group": "Integrations", + "icon": "plug", + "pages": [ + "integrations", + "integrations/langchain", + "integrations/langgraph", + "integrations/llama-index", + "integrations/agno", + "integrations/autogen", + "integrations/crewai", + "integrations/openai-agents-sdk", + "integrations/google-ai-adk", + "integrations/mastra", + "integrations/vercel-ai-sdk", + "integrations/livekit", + "integrations/pipecat", + "integrations/elevenlabs", + "integrations/aws-bedrock", + "integrations/flowise", + "integrations/langchain-tools", + "integrations/agentops", + "integrations/keywords", + "integrations/dify", + "integrations/raycast" + ] + } + ] + }, + { + "tab": "API Reference", + "icon": "square-terminal", + "groups": [ + { + "group": "API Reference", + "icon": "terminal", + "pages": [ + "api-reference", + { + "group": "Memory APIs", + "icon": "microchip", + "pages": [ + "api-reference/memory/add-memories", + "api-reference/memory/v2-search-memories", + "api-reference/memory/v1-search-memories", + "api-reference/memory/v2-get-memories", + "api-reference/memory/v1-get-memories", + "api-reference/memory/history-memory", + "api-reference/memory/get-memory", + "api-reference/memory/update-memory", + "api-reference/memory/batch-update", + "api-reference/memory/delete-memory", + "api-reference/memory/batch-delete", + "api-reference/memory/delete-memories", + "api-reference/memory/create-memory-export", + "api-reference/memory/get-memory-export", + "api-reference/memory/feedback" + ] + }, + { + "group": "Entities APIs", + "icon": "users", + "pages": [ + "api-reference/entities/get-users", + "api-reference/entities/delete-user" + ] + }, + { + "group": "Organizations APIs", + "icon": "building", + "pages": [ + "api-reference/organization/create-org", + "api-reference/organization/get-orgs", + "api-reference/organization/get-org", + "api-reference/organization/get-org-members", + "api-reference/organization/add-org-member", + "api-reference/organization/delete-org" + ] + }, + { + "group": "Project APIs", + "icon": "folder", + "pages": [ + "api-reference/project/create-project", + "api-reference/project/get-projects", + "api-reference/project/get-project", + "api-reference/project/get-project-members", + "api-reference/project/add-project-member", + "api-reference/project/delete-project" + ] + }, + { + "group": "Webhook APIs", + "icon": "webhook", + "pages": [ + "api-reference/webhook/create-webhook", + "api-reference/webhook/get-webhook", + "api-reference/webhook/update-webhook", + "api-reference/webhook/delete-webhook" ] } ] @@ -197,177 +392,223 @@ ] }, { - "group": "Contribution", - "icon": "handshake", - "pages": [ - "contributing/development", - "contributing/documentation" - ] - } - ] - }, - { - "tab": "OpenMemory", - "icon": "square-terminal", - "pages": [ - "openmemory/overview", - "openmemory/quickstart", - "openmemory/integrations" - ] - }, - { - "tab": "Examples", - "groups": [ - { - "group": "💡 Examples", - "icon": "lightbulb", - "pages": [ - "examples", - "examples/aws_example", - "examples/aws_neptune_analytics_hybrid_store", - "examples/mem0-demo", - "examples/ai_companion_js", - "examples/collaborative-task-agent", - "examples/llamaindex-multiagent-learning-system", - "examples/personalized-search-tavily-mem0", - "examples/eliza_os", - "examples/mem0-mastra", - "examples/mem0-with-ollama", - "examples/personal-ai-tutor", - "examples/customer-support-agent", - "examples/personal-travel-assistant", - "examples/llama-index-mem0", - "examples/chrome-extension", - "examples/memory-guided-content-writing", - "examples/multimodal-demo", - "examples/personalized-deep-research", - "examples/mem0-agentic-tool", - "examples/openai-inbuilt-tools", - "examples/mem0-openai-voice-demo", - "examples/mem0-google-adk-healthcare-assistant", - "examples/email_processing", - "examples/youtube-assistant" - ] - } - ] - }, - { - "tab": "Integrations", - "groups": [ - { - "group": "Integrations", - "icon": "plug", - "pages": [ - "integrations", - "integrations/langchain", - "integrations/langgraph", - "integrations/llama-index", - "integrations/agno", - "integrations/autogen", - "integrations/crewai", - "integrations/openai-agents-sdk", - "integrations/google-ai-adk", - "integrations/mastra", - "integrations/vercel-ai-sdk", - "integrations/livekit", - "integrations/pipecat", - "integrations/elevenlabs", - "integrations/aws-bedrock", - "integrations/flowise", - "integrations/langchain-tools", - "integrations/agentops", - "integrations/keywords", - "integrations/dify", - "integrations/raycast" - ] - } - ] - }, - { - "tab": "API Reference", - "icon": "square-terminal", - "groups": [ - { - "group": "API Reference", - "icon": "terminal", - "pages": [ - "api-reference", + "tab": "Changelog", + "icon": "clock", + "groups": [ { - "group": "Memory APIs", - "icon": "microchip", + "group": "Product Updates", + "icon": "rocket", "pages": [ - "api-reference/memory/add-memories", - "api-reference/memory/v2-search-memories", - "api-reference/memory/v1-search-memories", - "api-reference/memory/v2-get-memories", - "api-reference/memory/v1-get-memories", - "api-reference/memory/history-memory", - "api-reference/memory/get-memory", - "api-reference/memory/update-memory", - "api-reference/memory/batch-update", - "api-reference/memory/delete-memory", - "api-reference/memory/batch-delete", - "api-reference/memory/delete-memories", - "api-reference/memory/create-memory-export", - "api-reference/memory/get-memory-export", - "api-reference/memory/feedback" - ] - }, - { - "group": "Entities APIs", - "icon": "users", - "pages": [ - "api-reference/entities/get-users", - "api-reference/entities/delete-user" - ] - }, - { - "group": "Organizations APIs", - "icon": "building", - "pages": [ - "api-reference/organization/create-org", - "api-reference/organization/get-orgs", - "api-reference/organization/get-org", - "api-reference/organization/get-org-members", - "api-reference/organization/add-org-member", - "api-reference/organization/delete-org" - ] - }, - { - "group": "Project APIs", - "icon": "folder", - "pages": [ - "api-reference/project/create-project", - "api-reference/project/get-projects", - "api-reference/project/get-project", - "api-reference/project/get-project-members", - "api-reference/project/add-project-member", - "api-reference/project/delete-project" - ] - }, - { - "group": "Webhook APIs", - "icon": "webhook", - "pages": [ - "api-reference/webhook/create-webhook", - "api-reference/webhook/get-webhook", - "api-reference/webhook/update-webhook", - "api-reference/webhook/delete-webhook" + "changelog" ] } ] } ] - }, + } + ] + }, + { + "version": "v0.x Legacy", + "anchors": [ { - "tab": "Changelog", - "icon": "clock", - "groups": [ + "anchor": "Documentation", + "icon": "book-open", + "tabs": [ { - "group": "Product Updates", - "icon": "rocket", - "pages": [ - "changelog" + "tab": "Documentation", + "groups": [ + { + "group": "Getting Started", + "icon": "rocket", + "pages": [ + "v0x/introduction", + "v0x/quickstart", + "v0x/faqs" + ] + }, + { + "group": "Core Concepts", + "icon": "brain", + "pages": [ + "v0x/core-concepts/memory-types", + { + "group": "Memory Operations", + "icon": "gear", + "pages": [ + "v0x/core-concepts/memory-operations/add", + "v0x/core-concepts/memory-operations/search", + "v0x/core-concepts/memory-operations/update", + "v0x/core-concepts/memory-operations/delete" + ] + } + ] + }, + { + "group": "Open Source", + "icon": "code-branch", + "pages": [ + "v0x/open-source/overview", + "v0x/open-source/python-quickstart", + "v0x/open-source/node-quickstart", + { + "group": "LLMs", + "icon": "brain", + "pages": [ + "v0x/components/llms/overview", + "v0x/components/llms/config", + { + "group": "Supported LLMs", + "icon": "list", + "pages": [ + "v0x/components/llms/models/openai", + "v0x/components/llms/models/anthropic", + "v0x/components/llms/models/azure_openai", + "v0x/components/llms/models/ollama", + "v0x/components/llms/models/together", + "v0x/components/llms/models/groq", + "v0x/components/llms/models/litellm", + "v0x/components/llms/models/mistral_AI", + "v0x/components/llms/models/google_AI", + "v0x/components/llms/models/aws_bedrock", + "v0x/components/llms/models/deepseek", + "v0x/components/llms/models/xAI", + "v0x/components/llms/models/sarvam", + "v0x/components/llms/models/lmstudio", + "v0x/components/llms/models/langchain", + "v0x/components/llms/models/vllm" + ] + } + ] + }, + { + "group": "Vector Databases", + "icon": "database", + "pages": [ + "v0x/components/vectordbs/overview", + "v0x/components/vectordbs/config", + { + "group": "Supported Vector Databases", + "icon": "server", + "pages": [ + "v0x/components/vectordbs/dbs/qdrant", + "v0x/components/vectordbs/dbs/chroma", + "v0x/components/vectordbs/dbs/pgvector", + "v0x/components/vectordbs/dbs/milvus", + "v0x/components/vectordbs/dbs/pinecone", + "v0x/components/vectordbs/dbs/mongodb", + "v0x/components/vectordbs/dbs/azure", + "v0x/components/vectordbs/dbs/redis", + "v0x/components/vectordbs/dbs/valkey", + "v0x/components/vectordbs/dbs/elasticsearch", + "v0x/components/vectordbs/dbs/opensearch", + "v0x/components/vectordbs/dbs/supabase", + "v0x/components/vectordbs/dbs/upstash-vector", + "v0x/components/vectordbs/dbs/vectorize", + "v0x/components/vectordbs/dbs/vertex_ai", + "v0x/components/vectordbs/dbs/weaviate", + "v0x/components/vectordbs/dbs/faiss", + "v0x/components/vectordbs/dbs/langchain", + "v0x/components/vectordbs/dbs/baidu", + "v0x/components/vectordbs/dbs/s3_vectors", + "v0x/components/vectordbs/dbs/databricks", + "v0x/components/vectordbs/dbs/neptune_analytics" + ] + } + ] + }, + { + "group": "Embedding Models", + "icon": "layer-group", + "pages": [ + "v0x/components/embedders/overview", + "v0x/components/embedders/config", + { + "group": "Supported Embedding Models", + "icon": "list", + "pages": [ + "v0x/components/embedders/models/openai", + "v0x/components/embedders/models/azure_openai", + "v0x/components/embedders/models/ollama", + "v0x/components/embedders/models/huggingface", + "v0x/components/embedders/models/vertexai", + "v0x/components/embedders/models/google_AI", + "v0x/components/embedders/models/lmstudio", + "v0x/components/embedders/models/together", + "v0x/components/embedders/models/langchain", + "v0x/components/embedders/models/aws_bedrock" + ] + } + ] + } + ] + } + ] + }, + { + "tab": "Examples", + "groups": [ + { + "group": "💡 Examples", + "icon": "lightbulb", + "pages": [ + "v0x/examples/aws_example", + "v0x/examples/aws_neptune_analytics_hybrid_store", + "v0x/examples/mem0-demo", + "v0x/examples/ai_companion_js", + "v0x/examples/collaborative-task-agent", + "v0x/examples/llamaindex-multiagent-learning-system", + "v0x/examples/personalized-search-tavily-mem0", + "v0x/examples/eliza_os", + "v0x/examples/mem0-mastra", + "v0x/examples/mem0-with-ollama", + "v0x/examples/personal-ai-tutor", + "v0x/examples/customer-support-agent", + "v0x/examples/personal-travel-assistant", + "v0x/examples/llama-index-mem0", + "v0x/examples/chrome-extension", + "v0x/examples/memory-guided-content-writing", + "v0x/examples/multimodal-demo", + "v0x/examples/personalized-deep-research", + "v0x/examples/mem0-agentic-tool", + "v0x/examples/openai-inbuilt-tools", + "v0x/examples/mem0-openai-voice-demo", + "v0x/examples/mem0-google-adk-healthcare-assistant", + "v0x/examples/email_processing", + "v0x/examples/youtube-assistant" + ] + } + ] + }, + { + "tab": "Integrations", + "groups": [ + { + "group": "Integrations", + "icon": "plug", + "pages": [ + "v0x/integrations/langchain", + "v0x/integrations/langgraph", + "v0x/integrations/llama-index", + "v0x/integrations/agno", + "v0x/integrations/autogen", + "v0x/integrations/crewai", + "v0x/integrations/openai-agents-sdk", + "v0x/integrations/google-ai-adk", + "v0x/integrations/mastra", + "v0x/integrations/vercel-ai-sdk", + "v0x/integrations/livekit", + "v0x/integrations/pipecat", + "v0x/integrations/elevenlabs", + "v0x/integrations/aws-bedrock", + "v0x/integrations/flowise", + "v0x/integrations/langchain-tools", + "v0x/integrations/agentops", + "v0x/integrations/keywords", + "v0x/integrations/dify", + "v0x/integrations/raycast" + ] + } ] } ] diff --git a/docs/examples.mdx b/docs/examples.mdx index 908dc4aeb..4d97d0782 100644 --- a/docs/examples.mdx +++ b/docs/examples.mdx @@ -54,7 +54,7 @@ Explore how **Mem0** can power real-world applications and bring personalized, i Integrate **Mem0** into **YouTube's** native UI, providing personalized responses with video context. - + Create a **Writing Assistant** that understands and adapts to your unique style, improving consistency and productivity. diff --git a/docs/integrations.mdx b/docs/integrations.mdx index 13c885313..d8f9b93a1 100644 --- a/docs/integrations.mdx +++ b/docs/integrations.mdx @@ -215,28 +215,6 @@ Here are the available integrations for Mem0: > Build AI applications with persistent memory using Dify and Mem0. - - - - } - href="/integrations/mcp-server" - > - Integrate Mem0 as an MCP Server in Cursor. - diff --git a/docs/introduction.mdx b/docs/introduction.mdx index 431494beb..587202000 100644 --- a/docs/introduction.mdx +++ b/docs/introduction.mdx @@ -20,7 +20,7 @@ Most current agents are stateless: they process a query, generate a response, an Stateful agents, powered by Mem0, are different. They retain context, recall what matters, and behave more intelligently over time. - + @@ -29,7 +29,7 @@ Stateful agents, powered by Mem0, are different. They retain context, recall wha Mem0 sits alongside your retriever, planner, and LLM. Unlike retrieval-based systems (like RAG), Mem0 tracks past interactions, stores long-term knowledge, and evolves the agent’s behavior. - + Memory is not about pushing more tokens into a prompt but about intelligently remembering context that matters. This distinction matters: diff --git a/docs/logo/Favicon copy.png b/docs/logo/Favicon copy.png new file mode 100644 index 0000000000000000000000000000000000000000..683d39cb2672d712dc21d84867d20f92abb713a3 GIT binary patch literal 67249 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 rsp?3hAYFQ_ry Union[List[dict], dict] +``` + +#### v1.0 Beta Signature +```python +def add( + self, + messages, + user_id: str = None, + agent_id: str = None, + run_id: str = None, + metadata: dict = None, + filters: dict = None, + infer: bool = True # ✅ NEW: Control memory inference +) -> dict # Always returns dict with "results" key +``` + +#### Changes Summary + +| Parameter | v0.x | v1.0 Beta | Change | +|-----------|------|-----------|---------| +| `messages` | ✅ | ✅ | Unchanged | +| `user_id` | ✅ | ✅ | Unchanged | +| `agent_id` | ✅ | ✅ | Unchanged | +| `run_id` | ✅ | ✅ | Unchanged | +| `metadata` | ✅ | ✅ | Unchanged | +| `filters` | ✅ | ✅ | Unchanged | +| `output_format` | ✅ | ❌ | **REMOVED** | +| `version` | ✅ | ❌ | **REMOVED** | +| `async_mode` | ✅ | ❌ | **REMOVED** | +| `infer` | ❌ | ✅ | **NEW** | + +#### Response Format Changes + +**v0.x Response (variable format):** +```python +# With output_format="v1.0" +[ + { + "id": "mem_123", + "memory": "User loves pizza", + "event": "ADD" + } +] + +# With output_format="v1.1" +{ + "results": [ + { + "id": "mem_123", + "memory": "User loves pizza", + "event": "ADD" + } + ] +} +``` + +**v1.0 Beta Response (standardized):** +```python +# Always returns this format +{ + "results": [ + { + "id": "mem_123", + "memory": "User loves pizza", + "metadata": {...}, + "event": "ADD" + } + ] +} +``` + +### search() Method + +#### v0.x Signature +```python +def search( + self, + query: str, + user_id: str = None, + agent_id: str = None, + run_id: str = None, + limit: int = 100, + filters: dict = None, # Basic key-value only + output_format: str = None, # ❌ REMOVED + version: str = None # ❌ REMOVED +) -> Union[List[dict], dict] +``` + +#### v1.0 Beta Signature +```python +def search( + self, + query: str, + user_id: str = None, + agent_id: str = None, + run_id: str = None, + limit: int = 100, + filters: dict = None, # ✅ ENHANCED: Advanced operators + rerank: bool = True # ✅ NEW: Reranking support +) -> dict # Always returns dict with "results" key +``` + +#### Enhanced Filtering + +**v0.x Filters (basic):** +```python +# Simple key-value filtering only +filters = { + "category": "food", + "user_id": "alice" +} +``` + +**v1.0 Beta Filters (enhanced):** +```python +# Advanced filtering with operators +filters = { + "AND": [ + {"category": "food"}, + {"score": {"gte": 0.8}}, + { + "OR": [ + {"priority": "high"}, + {"urgent": True} + ] + } + ] +} + +# Comparison operators +filters = { + "score": {"gt": 0.5}, # Greater than + "priority": {"gte": 5}, # Greater than or equal + "rating": {"lt": 3}, # Less than + "confidence": {"lte": 0.9}, # Less than or equal + "status": {"eq": "active"}, # Equal + "archived": {"ne": True}, # Not equal + "tags": {"in": ["work", "personal"]}, # In list + "category": {"nin": ["spam", "deleted"]} # Not in list +} +``` + +### get_all() Method + +#### v0.x Signature +```python +def get_all( + self, + user_id: str = None, + agent_id: str = None, + run_id: str = None, + filters: dict = None, + output_format: str = None, # ❌ REMOVED + version: str = None # ❌ REMOVED +) -> Union[List[dict], dict] +``` + +#### v1.0 Beta Signature +```python +def get_all( + self, + user_id: str = None, + agent_id: str = None, + run_id: str = None, + filters: dict = None # ✅ ENHANCED: Advanced operators +) -> dict # Always returns dict with "results" key +``` + +### update() Method + +#### No Breaking Changes +```python +# Same signature in both versions +def update( + self, + memory_id: str, + data: str +) -> dict +``` + +### delete() Method + +#### No Breaking Changes +```python +# Same signature in both versions +def delete( + self, + memory_id: str +) -> dict +``` + +### delete_all() Method + +#### No Breaking Changes +```python +# Same signature in both versions +def delete_all( + self, + user_id: str +) -> dict +``` + +## AsyncMemory Class Changes + +### Enhanced Async Support + +#### v0.x (Limited) +```python +from mem0 import AsyncMemory + +# Basic async support +async_m = AsyncMemory() +result = await async_m.add("content", user_id="alice", async_mode=True) +``` + +#### v1.0 Beta (Optimized) +```python +from mem0 import AsyncMemory + +# Optimized async by default +async_m = AsyncMemory() +result = await async_m.add("content", user_id="alice") # async_mode removed + +# All methods are now properly async-optimized +results = await async_m.search("query", user_id="alice", rerank=True) +``` + +## Configuration Changes + +### Memory Configuration + +#### v0.x Config Options +```python +config = { + "vector_store": {...}, + "llm": {...}, + "embedder": {...}, + "graph_store": {...}, + "version": "v1.0", # ❌ v1.0 no longer supported + "history_db_path": "...", + "custom_fact_extraction_prompt": "..." +} +``` + +#### v1.0 Beta Config Options +```python +config = { + "vector_store": {...}, + "llm": {...}, + "embedder": {...}, + "graph_store": {...}, + "reranker": { # ✅ NEW: Reranker support + "provider": "cohere", + "config": {...} + }, + "version": "v1.1", # ✅ v1.1+ only + "history_db_path": "...", + "custom_fact_extraction_prompt": "...", + "custom_update_memory_prompt": "..." # ✅ NEW: Custom update prompt +} +``` + +### New Configuration Options + +#### Reranker Configuration +```python +# Cohere reranker +"reranker": { + "provider": "cohere", + "config": { + "model": "rerank-english-v3.0", + "api_key": "your-api-key", + "top_k": 10 + } +} + +# Sentence Transformer reranker +"reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2", + "device": "cuda" + } +} + +# Hugging Face reranker +"reranker": { + "provider": "huggingface", + "config": { + "model": "BAAI/bge-reranker-base", + "device": "cuda" + } +} + +# LLM-based reranker +"reranker": { + "provider": "llm_reranker", + "config": { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4", + "api_key": "your-api-key" + } + } + } +} +``` + +## Error Handling Changes + +### New Error Types + +#### v0.x Errors +```python +# Generic exceptions +try: + result = m.add("content", user_id="alice", version="v1.0") +except Exception as e: + print(f"Error: {e}") +``` + +#### v1.0 Beta Errors +```python +# More specific error handling +try: + result = m.add("content", user_id="alice") +except ValueError as e: + if "v1.0 API format is no longer supported" in str(e): + # Handle version compatibility error + pass + elif "Invalid filter operator" in str(e): + # Handle filter syntax error + pass +except TypeError as e: + # Handle parameter errors + pass +except Exception as e: + # Handle unexpected errors + pass +``` + +### Validation Changes + +#### Stricter Parameter Validation + +**v0.x (Lenient):** +```python +# Unknown parameters might be ignored +result = m.add("content", user_id="alice", unknown_param="value") +``` + +**v1.0 Beta (Strict):** +```python +# Unknown parameters raise TypeError +try: + result = m.add("content", user_id="alice", unknown_param="value") +except TypeError as e: + print(f"Invalid parameter: {e}") +``` + +## Response Schema Changes + +### Memory Object Schema + +#### v0.x Schema +```python +{ + "id": "mem_123", + "memory": "User loves pizza", + "user_id": "alice", + "metadata": {...}, + "created_at": "2024-01-01T00:00:00Z", + "updated_at": "2024-01-01T00:00:00Z", + "score": 0.95 # In search results +} +``` + +#### v1.0 Beta Schema (Enhanced) +```python +{ + "id": "mem_123", + "memory": "User loves pizza", + "user_id": "alice", + "agent_id": "assistant", # ✅ More context + "run_id": "session_001", # ✅ More context + "metadata": {...}, + "categories": ["food"], # ✅ NEW: Auto-categorization + "immutable": false, # ✅ NEW: Immutability flag + "created_at": "2024-01-01T00:00:00Z", + "updated_at": "2024-01-01T00:00:00Z", + "score": 0.95, # In search results + "rerank_score": 0.98 # ✅ NEW: If reranking used +} +``` + +## Migration Code Examples + +### Simple Migration + +#### Before (v0.x) +```python +from mem0 import Memory + +m = Memory() + +# Add with deprecated parameters +result = m.add( + "I love pizza", + user_id="alice", + output_format="v1.1", + version="v1.0" +) + +# Handle variable response format +if isinstance(result, list): + memories = result +else: + memories = result.get("results", []) + +for memory in memories: + print(memory["memory"]) +``` + +#### After (v1.0 Beta) +```python +from mem0 import Memory + +m = Memory() + +# Add without deprecated parameters +result = m.add( + "I love pizza", + user_id="alice" +) + +# Always dict format with "results" key +for memory in result["results"]: + print(memory["memory"]) +``` + +### Advanced Migration + +#### Before (v0.x) +```python +# Basic filtering +results = m.search( + "food preferences", + user_id="alice", + filters={"category": "food"}, + output_format="v1.1" +) +``` + +#### After (v1.0 Beta) +```python +# Enhanced filtering with reranking +results = m.search( + "food preferences", + user_id="alice", + filters={ + "AND": [ + {"category": "food"}, + {"score": {"gte": 0.8}} + ] + }, + rerank=True +) +``` + +## Summary + +| Component | v0.x | v1.0 Beta | Status | +|-----------|------|-----------|---------| +| `add()` method | Variable response | Standardized response | ⚠️ Breaking | +| `search()` method | Basic filtering | Enhanced filtering + reranking | ⚠️ Breaking | +| `get_all()` method | Variable response | Standardized response | ⚠️ Breaking | +| Response format | Variable | Always `{"results": [...]}` | ⚠️ Breaking | +| Reranking | ❌ Not available | ✅ Full support | ✅ New feature | +| Advanced filtering | ❌ Basic only | ✅ Full operators | ✅ Enhancement | +| Error handling | Generic | Specific error types | ✅ Improvement | + + +Use this reference to systematically update your codebase. Test each change thoroughly before deploying to production. + \ No newline at end of file diff --git a/docs/migration/breaking-changes.mdx b/docs/migration/breaking-changes.mdx new file mode 100644 index 000000000..42a3fcd40 --- /dev/null +++ b/docs/migration/breaking-changes.mdx @@ -0,0 +1,404 @@ +--- +title: Breaking Changes in v1.0 Beta +description: 'Complete list of breaking changes when upgrading from v0.x to v1.0 Beta' +icon: "triangle-exclamation" +iconType: "solid" +--- + + +**Important:** This page lists all breaking changes. Please review carefully before upgrading. + + +## API Version Changes + +### Removed v1.0 API Support + +**Breaking Change:** The v1.0 API format is completely removed and no longer supported. + +#### Before (v0.x) +```python +# This was supported in v0.x +config = { + "version": "v1.0" # ❌ No longer supported +} + +result = m.add( + "memory content", + user_id="alice", + output_format="v1.0" # ❌ No longer supported +) +``` + +#### After (v1.0 Beta) +```python +# v1.1 is the minimum supported version +config = { + "version": "v1.1" # ✅ Required minimum +} + +result = m.add( + "memory content", + user_id="alice" + # output_format parameter removed +) +``` + +**Error Message:** +``` +ValueError: The v1.0 API format is no longer supported in mem0ai 1.0.0+. +Please use v1.1 format which returns a dict with 'results' key. +``` + +## Parameter Removals + +### 1. output_format Parameter + +**Removed from all methods:** +- `add()` +- `search()` +- `get_all()` + +#### Before (v0.x) +```python +result = m.add("content", user_id="alice", output_format="v1.1") +search_results = m.search("query", user_id="alice", output_format="v1.1") +all_memories = m.get_all(user_id="alice", output_format="v1.1") +``` + +#### After (v1.0 Beta) +```python +result = m.add("content", user_id="alice") +search_results = m.search("query", user_id="alice") +all_memories = m.get_all(user_id="alice") +``` + +### 2. version Parameter in Method Calls + +**Breaking Change:** Version parameter removed from method calls. + +#### Before (v0.x) +```python +result = m.add("content", user_id="alice", version="v1.0") +``` + +#### After (v1.0 Beta) +```python +result = m.add("content", user_id="alice") +``` + +### 3. async_mode Parameter + +**Breaking Change:** Async mode is now default and the parameter is removed. + +#### Before (v0.x) +```python +# Optional async mode +result = m.add("content", user_id="alice", async_mode=True) +result = m.add("content", user_id="alice", async_mode=False) # Sync mode +``` + +#### After (v1.0 Beta) +```python +# Always async by design, parameter removed +result = m.add("content", user_id="alice") + +# For async operations, use AsyncMemory +from mem0 import AsyncMemory +async_m = AsyncMemory() +result = await async_m.add("content", user_id="alice") +``` + +## Response Format Changes + +### Standardized Response Structure + +**Breaking Change:** All responses now return a standardized dictionary format. + +#### Before (v0.x) +```python +# Could return different formats based on output_format parameter +result = m.add("content", user_id="alice", output_format="v1.0") +# Returns: [{"id": "...", "memory": "...", "event": "ADD"}] + +result = m.add("content", user_id="alice", output_format="v1.1") +# Returns: {"results": [{"id": "...", "memory": "...", "event": "ADD"}]} +``` + +#### After (v1.0 Beta) +```python +# Always returns standardized format +result = m.add("content", user_id="alice") +# Always returns: {"results": [{"id": "...", "memory": "...", "event": "ADD"}]} + +# Access results consistently +for memory in result["results"]: + print(memory["memory"]) +``` + +## Configuration Changes + +### Version Configuration + +**Breaking Change:** Default API version changed. + +#### Before (v0.x) +```python +# v1.0 was supported +config = { + "version": "v1.0" # ❌ No longer supported +} +``` + +#### After (v1.0 Beta) +```python +# v1.1 is minimum, v1.1 is default +config = { + "version": "v1.1" # ✅ Minimum supported +} + +# Or omit for default +config = { + # version defaults to v1.1 +} +``` + +### Memory Configuration + +**Breaking Change:** Some configuration options have changed defaults. + +#### Before (v0.x) +```python +from mem0 import Memory + +# Default configuration in v0.x +m = Memory() # Used default settings suitable for v0.x +``` + +#### After (v1.0 Beta) +```python +from mem0 import Memory + +# Default configuration optimized for v1.0 Beta +m = Memory() # Uses v1.1+ optimized defaults + +# Explicit configuration recommended +config = { + "version": "v1.1", + "vector_store": { + "provider": "qdrant", + "config": { + "host": "localhost", + "port": 6333 + } + } +} +m = Memory.from_config(config) +``` + +## Method Signature Changes + +### Search Method + +**Enhanced but backward compatible:** + +#### Before (v0.x) +```python +results = m.search( + "query", + user_id="alice", + filters={"key": "value"} # Simple key-value only +) +``` + +#### After (v1.0 Beta) +```python +# Basic usage remains the same +results = m.search("query", user_id="alice") + +# Enhanced filtering available (optional) +results = m.search( + "query", + user_id="alice", + filters={ + "AND": [ + {"key": "value"}, + {"score": {"gte": 0.8}} + ] + }, + rerank=True # New parameter +) +``` + +## Error Handling Changes + +### New Error Types + +**Breaking Change:** More specific error types and messages. + +#### Before (v0.x) +```python +try: + result = m.add("content", user_id="alice", version="v1.0") +except Exception as e: + print(f"Generic error: {e}") +``` + +#### After (v1.0 Beta) +```python +try: + result = m.add("content", user_id="alice") +except ValueError as e: + if "v1.0 API format is no longer supported" in str(e): + # Handle version error specifically + print("Please upgrade your code to use v1.1+ format") + else: + print(f"Value error: {e}") +except Exception as e: + print(f"Unexpected error: {e}") +``` + +### Validation Changes + +**Breaking Change:** Stricter parameter validation. + +#### Before (v0.x) +```python +# Some invalid parameters might have been ignored +result = m.add( + "content", + user_id="alice", + invalid_param="ignored" # Might have been silently ignored +) +``` + +#### After (v1.0 Beta) +```python +# Strict validation - unknown parameters cause errors +try: + result = m.add( + "content", + user_id="alice", + invalid_param="value" # ❌ Will raise TypeError + ) +except TypeError as e: + print(f"Invalid parameter: {e}") +``` + +## Import Changes + +### No Breaking Changes in Imports + +**Good News:** Import statements remain the same. + +```python +# These imports work in both v0.x and v1.0 Beta +from mem0 import Memory, AsyncMemory +from mem0 import MemoryConfig +``` + +## Dependency Changes + +### Minimum Python Version + +**Potential Breaking Change:** Check Python version requirements. + +#### Before (v0.x) +- Python 3.8+ supported + +#### After (v1.0 Beta) +- Python 3.9+ required (check current requirements) + +### Package Dependencies + +**Breaking Change:** Some dependencies updated with potential breaking changes. + +```bash +# Check for conflicts after upgrade +pip install --upgrade mem0ai +pip check # Verify no dependency conflicts +``` + +## Data Migration + +### Database Schema + +**Good News:** No database schema changes required. + +- Existing memories remain compatible +- No data migration required +- Vector store data unchanged + +### Memory Format + +**Good News:** Memory storage format unchanged. + +- Existing memories work with v1.0 Beta +- Search continues to work with old memories +- No re-indexing required + +## Testing Changes + +### Test Updates Required + +**Breaking Change:** Update tests for new response format. + +#### Before (v0.x) +```python +def test_add_memory(): + result = m.add("content", user_id="alice") + assert isinstance(result, list) # ❌ No longer true + assert len(result) > 0 +``` + +#### After (v1.0 Beta) +```python +def test_add_memory(): + result = m.add("content", user_id="alice") + assert isinstance(result, dict) # ✅ Always dict + assert "results" in result # ✅ Always has results key + assert len(result["results"]) > 0 +``` + +## Rollback Considerations + +### Safe Rollback Process + +If you need to rollback: + +```bash +# 1. Rollback package +pip install mem0ai==0.1.20 # Last stable v0.x + +# 2. Revert code changes +git checkout previous_commit + +# 3. Test functionality +python test_mem0_functionality.py +``` + +### Data Safety + +- **Safe:** Memories stored in v0.x format work with v1.0 Beta +- **Safe:** Rollback doesn't lose data +- **Safe:** Vector store data remains intact + +## Next Steps + +1. **Review all breaking changes** in your codebase +2. **Update method calls** to remove deprecated parameters +3. **Update response handling** to use standardized format +4. **Test thoroughly** with your existing data +5. **Update error handling** for new error types + + + + Step-by-step migration instructions + + + Complete API reference changes + + + + +**Need Help?** If you encounter issues during migration, check our [GitHub Discussions](https://github.com/mem0ai/mem0/discussions) or community support channels. + \ No newline at end of file diff --git a/docs/migration/v0-to-v1.mdx b/docs/migration/v0-to-v1.mdx new file mode 100644 index 000000000..4040d1c58 --- /dev/null +++ b/docs/migration/v0-to-v1.mdx @@ -0,0 +1,491 @@ +--- +title: Migrating from v0.x to v1.0 Beta +description: 'Complete guide to upgrade your Mem0 implementation to version 1.0.0 Beta' +icon: "arrow-right" +iconType: "solid" +--- + + +**Breaking Changes Ahead!** Mem0 1.0.0 Beta introduces several breaking changes. Please read this guide carefully before upgrading. + + +## Overview + +Mem0 1.0.0 Beta is a major release that modernizes the API, improves performance, and adds powerful new features. This guide will help you migrate your existing v0.x implementation to the new version. + +## Key Changes Summary + +| Feature | v0.x | v1.0.0 Beta | Migration Required | +|---------|------|-------------|-------------------| +| API Version | v1.0 supported | v1.0 **removed**, v1.1+ only | ✅ Yes | +| Async Mode | Optional | Default and required | ✅ Yes | +| Output Format Parameter | Supported | **Removed** | ✅ Yes | +| Response Format | Mixed | Standardized `{"results": [...]}` | ✅ Yes | +| Metadata Filtering | Basic | Enhanced with operators | ⚠️ Optional | +| Reranking | Not available | Full support | ⚠️ Optional | + +## Step-by-Step Migration + +### 1. Update Installation + +```bash +# Update to the latest version +pip install --upgrade mem0ai +``` + +### 2. Remove Deprecated Parameters + +#### Before (v0.x) +```python +from mem0 import Memory + +# These parameters are no longer supported +m = Memory() +result = m.add( + "I love pizza", + user_id="alice", + output_format="v1.0", # ❌ REMOVED + version="v1.0" # ❌ REMOVED +) +``` + +#### After (v1.0.0 Beta) +```python +from mem0 import Memory + +# Clean, simplified API +m = Memory() +result = m.add( + "I love pizza", + user_id="alice" + # output_format and version parameters removed +) +``` + +### 3. Update Configuration + +#### Before (v0.x) +```python +config = { + "vector_store": { + "provider": "qdrant", + "config": { + "host": "localhost", + "port": 6333 + } + }, + "version": "v1.0" # ❌ No longer supported +} + +m = Memory.from_config(config) +``` + +#### After (v1.0.0 Beta) +```python +config = { + "vector_store": { + "provider": "qdrant", + "config": { + "host": "localhost", + "port": 6333 + } + }, + "version": "v1.1" # ✅ v1.1 is the minimum supported version +} + +m = Memory.from_config(config) +``` + +### 4. Handle Response Format Changes + +#### Before (v0.x) +```python +# Response could be a list or dict depending on version +result = m.add("I love coffee", user_id="alice") + +if isinstance(result, list): + # Handle list format + for item in result: + print(item["memory"]) +else: + # Handle dict format + print(result["results"]) +``` + +#### After (v1.0.0 Beta) +```python +# Response is always a standardized dict with "results" key +result = m.add("I love coffee", user_id="alice") + +# Always access via "results" key +for item in result["results"]: + print(item["memory"]) +``` + +### 5. Update Search Operations + +#### Before (v0.x) +```python +# Basic search +results = m.search("What do I like?", user_id="alice") + +# With filters +results = m.search( + "What do I like?", + user_id="alice", + filters={"category": "food"} +) +``` + +#### After (v1.0.0 Beta) +```python +# Same basic search API +results = m.search("What do I like?", user_id="alice") + +# Enhanced filtering with operators (optional upgrade) +results = m.search( + "What do I like?", + user_id="alice", + filters={ + "AND": [ + {"category": "food"}, + {"rating": {"gte": 8}} + ] + } +) + +# New: Reranking support (optional) +results = m.search( + "What do I like?", + user_id="alice", + rerank=True # Requires reranker configuration +) +``` + +### 6. Migrate Async Operations + +#### Before (v0.x) +```python +from mem0 import AsyncMemory + +# Async was optional +async_memory = AsyncMemory() + +async def add_memory(): + result = await async_memory.add( + "I enjoy hiking", + user_id="alice", + async_mode=True # ❌ Parameter removed + ) + return result +``` + +#### After (v1.0.0 Beta) +```python +from mem0 import AsyncMemory + +# Async is the default mode +async_memory = AsyncMemory() + +async def add_memory(): + result = await async_memory.add( + "I enjoy hiking", + user_id="alice" + # async_mode parameter removed - always async + ) + return result +``` + +## Configuration Migration + +### Basic Configuration + +#### Before (v0.x) +```python +config = { + "vector_store": { + "provider": "qdrant", + "config": { + "host": "localhost", + "port": 6333 + } + }, + "llm": { + "provider": "openai", + "config": { + "model": "gpt-3.5-turbo", + "api_key": "your-key" + } + }, + "version": "v1.0" +} +``` + +#### After (v1.0.0 Beta) +```python +config = { + "vector_store": { + "provider": "qdrant", + "config": { + "host": "localhost", + "port": 6333 + } + }, + "llm": { + "provider": "openai", + "config": { + "model": "gpt-3.5-turbo", + "api_key": "your-key" + } + }, + "version": "v1.1", # Minimum supported version + + # New optional features + "reranker": { + "provider": "cohere", + "config": { + "model": "rerank-english-v3.0", + "api_key": "your-cohere-key" + } + } +} +``` + +### Enhanced Features (Optional) + +```python +# Take advantage of new features +config = { + "vector_store": { + "provider": "qdrant", + "config": { + "host": "localhost", + "port": 6333 + } + }, + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4", + "api_key": "your-key" + } + }, + "embedder": { + "provider": "openai", + "config": { + "model": "text-embedding-3-small", + "api_key": "your-key" + } + }, + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2" + } + }, + "version": "v1.1" +} +``` + +## Error Handling Migration + +### Before (v0.x) +```python +try: + result = m.add("memory", user_id="alice", version="v1.0") +except Exception as e: + print(f"Error: {e}") +``` + +### After (v1.0.0 Beta) +```python +try: + result = m.add("memory", user_id="alice") +except ValueError as e: + if "v1.0 API format is no longer supported" in str(e): + print("Please upgrade your code to use v1.1+ format") + else: + print(f"Error: {e}") +except Exception as e: + print(f"Unexpected error: {e}") +``` + +## Testing Your Migration + +### 1. Basic Functionality Test + +```python +def test_basic_functionality(): + m = Memory() + + # Test add + result = m.add("I love testing", user_id="test_user") + assert "results" in result + assert len(result["results"]) > 0 + + # Test search + search_results = m.search("testing", user_id="test_user") + assert "results" in search_results + + # Test get_all + all_memories = m.get_all(user_id="test_user") + assert "results" in all_memories + + print("✅ Basic functionality test passed") + +test_basic_functionality() +``` + +### 2. Enhanced Features Test + +```python +def test_enhanced_features(): + config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2" + } + } + } + + m = Memory.from_config(config) + + # Test reranking + m.add("I love advanced features", user_id="test_user") + results = m.search("features", user_id="test_user", rerank=True) + assert "results" in results + + # Test enhanced filtering + results = m.search( + "features", + user_id="test_user", + filters={"user_id": {"eq": "test_user"}} + ) + assert "results" in results + + print("✅ Enhanced features test passed") + +test_enhanced_features() +``` + +## Common Migration Issues + +### Issue 1: Version Error + +**Error:** +``` +ValueError: The v1.0 API format is no longer supported in mem0ai 1.0.0+ +``` + +**Solution:** +```python +# Remove version parameters or set to v1.1+ +config = { + # ... other config + "version": "v1.1" # or remove entirely for default +} +``` + +### Issue 2: Response Format Error + +**Error:** +``` +KeyError: 'results' +``` + +**Solution:** +```python +# Always access response via "results" key +result = m.add("memory", user_id="alice") +memories = result["results"] # Not result directly +``` + +### Issue 3: Parameter Error + +**Error:** +``` +TypeError: add() got an unexpected keyword argument 'output_format' +``` + +**Solution:** +```python +# Remove deprecated parameters +result = m.add( + "memory", + user_id="alice" + # Remove: output_format, version, async_mode +) +``` + +## Rollback Plan + +If you encounter issues during migration: + +### 1. Immediate Rollback + +```bash +# Downgrade to last v0.x version +pip install mem0ai==0.1.20 # Replace with your last working version +``` + +### 2. Gradual Migration + +```python +# Test both versions side by side +import mem0_v0 # Your old version +import mem0 # New version + +def compare_results(query, user_id): + old_results = mem0_v0.search(query, user_id=user_id) + new_results = mem0.search(query, user_id=user_id) + + print("Old format:", old_results) + print("New format:", new_results["results"]) +``` + +## Performance Improvements + +### Before (v0.x) +```python +# Sequential operations +result1 = m.add("memory 1", user_id="alice") +result2 = m.add("memory 2", user_id="alice") +result3 = m.search("query", user_id="alice") +``` + +### After (v1.0.0 Beta) +```python +# Better async performance +async def batch_operations(): + async_memory = AsyncMemory() + + # Concurrent operations + results = await asyncio.gather( + async_memory.add("memory 1", user_id="alice"), + async_memory.add("memory 2", user_id="alice"), + async_memory.search("query", user_id="alice") + ) + return results +``` + +## Next Steps + +1. **Complete the migration** using this guide +2. **Test thoroughly** with your existing data +3. **Explore new features** like enhanced filtering and reranking +4. **Update your documentation** to reflect the new API +5. **Monitor performance** and optimize as needed + + + + Detailed list of all breaking changes + + + Complete API reference changes + + + + +Need help with migration? Check our [GitHub Discussions](https://github.com/mem0ai/mem0/discussions) or reach out to our community for support. + \ No newline at end of file diff --git a/docs/open-source/features/metadata-filtering.mdx b/docs/open-source/features/metadata-filtering.mdx new file mode 100644 index 000000000..a73b6e1a3 --- /dev/null +++ b/docs/open-source/features/metadata-filtering.mdx @@ -0,0 +1,389 @@ +--- +title: Enhanced Metadata Filtering +description: 'Advanced filtering capabilities for precise memory retrieval in Mem0 1.0.0 Beta' +icon: "filter" +iconType: "solid" +--- + + +Enhanced metadata filtering is available in **Mem0 1.0.0 Beta** and later versions. This feature provides powerful filtering capabilities with logical operators and comparison functions. + + +## Overview + +Mem0 1.0.0 Beta introduces enhanced metadata filtering that allows you to perform complex queries on your memory metadata. You can now use logical operators, comparison functions, and advanced filtering patterns to retrieve exactly the memories you need. + +## Basic Filtering + +### Simple Key-Value Filtering + +```python +from mem0 import Memory + +m = Memory() + +# Search with simple metadata filters +results = m.search( + "What are my preferences?", + user_id="alice", + filters={"category": "preferences"} +) +``` + +### Exact Match Filtering + +```python +# Multiple exact match filters +results = m.search( + "movie recommendations", + user_id="alice", + filters={ + "category": "entertainment", + "type": "recommendation", + "priority": "high" + } +) +``` + +## Advanced Filtering with Operators + +### Comparison Operators + +```python +# Greater than / Less than +results = m.search( + "recent activities", + user_id="alice", + filters={ + "score": {"gt": 0.8}, # score > 0.8 + "priority": {"gte": 5}, # priority >= 5 + "confidence": {"lt": 0.9}, # confidence < 0.9 + "rating": {"lte": 3} # rating <= 3 + } +) + +# Equality operators +results = m.search( + "specific content", + user_id="alice", + filters={ + "status": {"eq": "active"}, # status == "active" + "archived": {"ne": True} # archived != True + } +) +``` + +### List-based Operators + +```python +# In / Not in operators +results = m.search( + "multi-category search", + user_id="alice", + filters={ + "category": {"in": ["food", "travel", "entertainment"]}, + "status": {"nin": ["deleted", "archived"]} + } +) +``` + +### String Operators + +```python +# Text matching operators +results = m.search( + "content search", + user_id="alice", + filters={ + "title": {"contains": "meeting"}, # case-sensitive contains + "description": {"icontains": "important"}, # case-insensitive contains + "tags": {"contains": "urgent"} + } +) +``` + +### Wildcard Matching + +```python +# Match any value for a field +results = m.search( + "all with category", + user_id="alice", + filters={ + "category": "*" # Any memory that has a category field + } +) +``` + +## Logical Operators + +### AND Operations + +```python +# Logical AND - all conditions must be true +results = m.search( + "complex query", + user_id="alice", + filters={ + "AND": [ + {"category": "work"}, + {"priority": {"gte": 7}}, + {"status": {"ne": "completed"}} + ] + } +) +``` + +### OR Operations + +```python +# Logical OR - any condition can be true +results = m.search( + "flexible query", + user_id="alice", + filters={ + "OR": [ + {"category": "urgent"}, + {"priority": {"gte": 9}}, + {"deadline": {"contains": "today"}} + ] + } +) +``` + +### NOT Operations + +```python +# Logical NOT - exclude matches +results = m.search( + "exclusion query", + user_id="alice", + filters={ + "NOT": [ + {"category": "archived"}, + {"status": "deleted"} + ] + } +) +``` + +### Complex Nested Logic + +```python +# Combine multiple logical operators +results = m.search( + "advanced query", + user_id="alice", + filters={ + "AND": [ + { + "OR": [ + {"category": "work"}, + {"category": "personal"} + ] + }, + {"priority": {"gte": 5}}, + { + "NOT": [ + {"status": "archived"} + ] + } + ] + } +) +``` + +## Real-world Examples + +### Project Management Filtering + +```python +# Find high-priority active tasks +results = m.search( + "What tasks need attention?", + user_id="project_manager", + filters={ + "AND": [ + {"project": {"in": ["alpha", "beta"]}}, + {"priority": {"gte": 8}}, + {"status": {"ne": "completed"}}, + { + "OR": [ + {"assignee": "alice"}, + {"assignee": "bob"} + ] + } + ] + } +) +``` + +### Customer Support Filtering + +```python +# Find recent unresolved tickets +results = m.search( + "pending support issues", + agent_id="support_bot", + filters={ + "AND": [ + {"ticket_status": {"ne": "resolved"}}, + {"priority": {"in": ["high", "critical"]}}, + {"created_date": {"gte": "2024-01-01"}}, + { + "NOT": [ + {"category": "spam"} + ] + } + ] + } +) +``` + +### Content Recommendation Filtering + +```python +# Personalized content filtering +results = m.search( + "recommend content", + user_id="reader123", + filters={ + "AND": [ + { + "OR": [ + {"genre": {"in": ["sci-fi", "fantasy"]}}, + {"author": {"contains": "favorite"}} + ] + }, + {"rating": {"gte": 4.0}}, + {"read_status": {"ne": "completed"}}, + {"language": "english"} + ] + } +) +``` + +## Performance Considerations + +### Indexing Strategy + +```python +# Ensure your vector store supports indexing on filtered fields +config = { + "vector_store": { + "provider": "qdrant", + "config": { + "host": "localhost", + "port": 6333, + # Enable indexing on frequently filtered fields + "indexed_fields": ["category", "priority", "status", "user_id"] + } + } +} +``` + +### Filter Optimization + +```python +# More efficient: Filter on indexed fields first +good_filters = { + "AND": [ + {"user_id": "alice"}, # Indexed field first + {"category": "work"}, # Then other indexed fields + {"content": {"contains": "meeting"}} # Text search last + ] +} + +# Less efficient: Complex operations first +avoid_filters = { + "AND": [ + {"description": {"icontains": "complex text search"}}, # Expensive first + {"user_id": "alice"} # Indexed field last + ] +} +``` + +## Vector Store Compatibility + +Different vector stores support different filtering capabilities: + +### Qdrant +-  Full support for all operators +-  Efficient nested logical operations +-  Indexed field optimization + +### Chroma +-  Basic operators (eq, ne, gt, lt, gte, lte) +-  Simple logical operations +-  Limited nested operations + +### Pinecone +-  Good support for comparison operators +-  In/nin operations +-  Limited text operations + +### Weaviate +-  Full operator support +-  Advanced text operations +-  Efficient filtering + +## Error Handling + +```python +try: + results = m.search( + "test query", + user_id="alice", + filters={ + "invalid_operator": {"unknown": "value"} + } + ) +except ValueError as e: + print(f"Filter error: {e}") + # Fallback to simple filtering + results = m.search( + "test query", + user_id="alice", + filters={"category": "general"} + ) +``` + +## Migration from Simple Filters + +### Before (v0.x) +```python +# Simple key-value filtering only +results = m.search( + "query", + user_id="alice", + filters={"category": "work", "status": "active"} +) +``` + +### After (v1.0.0 Beta) +```python +# Enhanced filtering with operators +results = m.search( + "query", + user_id="alice", + filters={ + "AND": [ + {"category": "work"}, + {"status": {"ne": "archived"}}, + {"priority": {"gte": 5}} + ] + } +) +``` + +## Best Practices + +1. **Use Indexed Fields**: Filter on indexed fields for better performance +2. **Combine Operators**: Use logical operators to create precise queries +3. **Test Filter Performance**: Benchmark complex filters with your data +4. **Graceful Degradation**: Implement fallbacks for unsupported operations +5. **Validate Filters**: Check filter syntax before executing queries + + +Enhanced metadata filtering provides powerful capabilities for precise memory retrieval. Start with simple filters and gradually adopt more complex patterns as needed. + \ No newline at end of file diff --git a/docs/open-source/features/overview.mdx b/docs/open-source/features/overview.mdx index acb4d9a3e..dbad389de 100644 --- a/docs/open-source/features/overview.mdx +++ b/docs/open-source/features/overview.mdx @@ -44,14 +44,14 @@ Choose your preferred approach: - **[Python Quickstart](../python-quickstart)**: Get started with Python SDK - **[Node.js Quickstart](../node-quickstart)**: Use Mem0 with Node.js/TypeScript -- **[Examples](../examples)**: Explore real-world use cases and implementations +- **[Examples](/examples)**: Explore real-world use cases and implementations ## Next Steps - Explore [specific features](./async-memory) in detail - Learn about [graph memory](../graph_memory/overview) capabilities -- Set up [vector databases](../components/vectordbs/overview) and [LLM integrations](../components/llms/overview) -- Check out our [examples](../examples) for practical implementations +- Set up [vector databases](/components/vectordbs/overview) and [LLM integrations](/components/llms/overview) +- Check out our [examples](/examples) for practical implementations - Join our [Discord community](https://mem0.dev/DiD) for support We're excited to see what you'll build with Mem0 open-source. Let's create smarter, more personalized AI experiences together! diff --git a/docs/open-source/features/reranker-search.mdx b/docs/open-source/features/reranker-search.mdx new file mode 100644 index 000000000..ec77d83d6 --- /dev/null +++ b/docs/open-source/features/reranker-search.mdx @@ -0,0 +1,418 @@ +--- +title: Reranker-Enhanced Search +description: 'Improve search relevance with reranking models in Mem0 1.0.0 Beta' +icon: "sort" +iconType: "solid" +--- + + +Reranker-enhanced search is available in **Mem0 1.0.0 Beta** and later versions. This feature significantly improves search relevance by using specialized reranking models to reorder search results. + + +## Overview + +Rerankers are specialized models that improve the quality of search results by reordering initially retrieved memories. They work as a second-stage ranking system that analyzes the semantic relationship between your query and retrieved memories to provide more relevant results. + +## How Reranking Works + +1. **Initial Vector Search**: Retrieves candidate memories using vector similarity +2. **Reranking**: Specialized model analyzes query-memory relationships +3. **Reordering**: Results are reordered based on semantic relevance +4. **Enhanced Results**: Final results with improved relevance scores + +## Configuration + +### Basic Setup + +```python +from mem0 import Memory + +config = { + "reranker": { + "provider": "cohere", + "config": { + "model": "rerank-english-v3.0", + "api_key": "your-cohere-api-key" + } + } +} + +m = Memory.from_config(config) +``` + +### Supported Providers + +#### Cohere Reranker + +```python +config = { + "reranker": { + "provider": "cohere", + "config": { + "model": "rerank-english-v3.0", + "api_key": "your-cohere-api-key", + "top_k": 10, # Number of results to rerank + "return_documents": True + } + } +} +``` + +#### Sentence Transformer Reranker + +```python +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2", + "device": "cuda", # Use GPU if available + "max_length": 512 + } + } +} +``` + +#### Hugging Face Reranker + +```python +config = { + "reranker": { + "provider": "huggingface", + "config": { + "model": "BAAI/bge-reranker-base", + "device": "cuda", + "batch_size": 32 + } + } +} +``` + +#### LLM-based Reranker + +```python +config = { + "reranker": { + "provider": "llm_reranker", + "config": { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4", + "api_key": "your-openai-api-key" + } + }, + "top_k": 5 + } + } +} +``` + +## Usage Examples + +### Basic Reranked Search + +```python +# Reranking is enabled by default when configured +results = m.search( + "What are my food preferences?", + user_id="alice" +) + +# Results are automatically reranked for better relevance +for result in results["results"]: + print(f"Memory: {result['memory']}") + print(f"Score: {result['score']}") +``` + +### Controlling Reranking + +```python +# Enable reranking explicitly +results_with_rerank = m.search( + "What movies do I like?", + user_id="alice", + rerank=True +) + +# Disable reranking for this search +results_without_rerank = m.search( + "What movies do I like?", + user_id="alice", + rerank=False +) + +# Compare the difference in results +print("With reranking:", len(results_with_rerank["results"])) +print("Without reranking:", len(results_without_rerank["results"])) +``` + +### Combining with Filters + +```python +# Reranking works with metadata filtering +results = m.search( + "important work tasks", + user_id="alice", + filters={ + "AND": [ + {"category": "work"}, + {"priority": {"gte": 7}} + ] + }, + rerank=True, + limit=20 +) +``` + +## Advanced Configuration + +### Complete Configuration Example + +```python +config = { + "vector_store": { + "provider": "qdrant", + "config": { + "host": "localhost", + "port": 6333 + } + }, + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4", + "api_key": "your-openai-api-key" + } + }, + "embedder": { + "provider": "openai", + "config": { + "model": "text-embedding-3-small", + "api_key": "your-openai-api-key" + } + }, + "reranker": { + "provider": "cohere", + "config": { + "model": "rerank-english-v3.0", + "api_key": "your-cohere-api-key", + "top_k": 15, + "return_documents": True + } + } +} + +m = Memory.from_config(config) +``` + +### Async Support + +```python +from mem0 import AsyncMemory + +# Reranking works with async operations +async_memory = AsyncMemory.from_config(config) + +async def search_with_rerank(): + results = await async_memory.search( + "What are my preferences?", + user_id="alice", + rerank=True + ) + return results + +# Use in async context +import asyncio +results = asyncio.run(search_with_rerank()) +``` + +## Performance Considerations + +### When to Use Reranking + +✅ **Good Use Cases:** +- Complex semantic queries +- Domain-specific searches +- When precision is more important than speed +- Large memory collections +- Ambiguous or nuanced queries + +❌ **Avoid When:** +- Simple keyword matching +- Real-time applications with strict latency requirements +- Small memory collections +- High-frequency searches where cost matters + +### Performance Optimization + +```python +# Optimize reranking performance +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2", + "device": "cuda", # Use GPU + "batch_size": 32, # Process in batches + "top_k": 10, # Limit candidates + "max_length": 256 # Reduce if appropriate + } + } +} +``` + +### Cost Management + +```python +# For API-based rerankers like Cohere +config = { + "reranker": { + "provider": "cohere", + "config": { + "model": "rerank-english-v3.0", + "api_key": "your-cohere-api-key", + "top_k": 5, # Reduce to control API costs + } + } +} + +# Use reranking selectively +def smart_search(query, user_id, use_rerank=None): + # Automatically decide when to use reranking + if use_rerank is None: + use_rerank = len(query.split()) > 3 # Complex queries only + + return m.search(query, user_id=user_id, rerank=use_rerank) +``` + +## Error Handling + +```python +try: + results = m.search( + "test query", + user_id="alice", + rerank=True + ) +except Exception as e: + print(f"Reranking failed: {e}") + # Gracefully fall back to vector search + results = m.search( + "test query", + user_id="alice", + rerank=False + ) +``` + +## Reranker Comparison + +| Provider | Latency | Quality | Cost | Local Deploy | +|----------|---------|---------|------|--------------| +| Cohere | Medium | High | API Cost | ❌ | +| Sentence Transformer | Low | Good | Free | ✅ | +| Hugging Face | Low-Medium | Variable | Free | ✅ | +| LLM Reranker | High | Very High | API Cost | Depends | + +## Real-world Examples + +### Customer Support + +```python +# Improve support ticket relevance +config = { + "reranker": { + "provider": "cohere", + "config": { + "model": "rerank-english-v3.0", + "api_key": "your-cohere-api-key" + } + } +} + +m = Memory.from_config(config) + +# Find relevant support cases +results = m.search( + "customer having login issues with mobile app", + agent_id="support_bot", + filters={"category": "technical_support"}, + rerank=True +) +``` + +### Content Recommendation + +```python +# Better content matching +results = m.search( + "science fiction books with space exploration themes", + user_id="reader123", + filters={"content_type": "book_recommendation"}, + rerank=True, + limit=10 +) + +for result in results["results"]: + print(f"Recommendation: {result['memory']}") + print(f"Relevance: {result['score']:.3f}") +``` + +### Personal Assistant + +```python +# Enhanced personal queries +results = m.search( + "What restaurants did I enjoy last month that had good vegetarian options?", + user_id="foodie_user", + filters={ + "AND": [ + {"category": "dining"}, + {"rating": {"gte": 4}}, + {"date": {"gte": "2024-01-01"}} + ] + }, + rerank=True +) +``` + +## Migration Guide + +### From v0.x (No Reranking) + +```python +# v0.x - basic vector search +results = m.search("query", user_id="alice") +``` + +### To v1.0.0 Beta (With Reranking) + +```python +# Add reranker configuration +config = { + "reranker": { + "provider": "sentence_transformer", + "config": { + "model": "cross-encoder/ms-marco-MiniLM-L-6-v2" + } + } +} + +m = Memory.from_config(config) + +# Same search API, better results +results = m.search("query", user_id="alice") # Automatically reranked +``` + +## Best Practices + +1. **Start Simple**: Begin with Sentence Transformers for local deployment +2. **Monitor Performance**: Track both relevance improvements and latency +3. **Cost Awareness**: Use API-based rerankers judiciously +4. **Selective Usage**: Apply reranking where it provides the most value +5. **Fallback Strategy**: Always handle reranking failures gracefully +6. **Test Different Models**: Experiment to find the best fit for your domain + + +Reranker-enhanced search significantly improves result relevance. Start with a local model and upgrade to API-based solutions as your needs grow. + \ No newline at end of file diff --git a/docs/open-source/graph_memory/overview.mdx b/docs/open-source/graph_memory/overview.mdx index 1df583210..e7ecd10b4 100644 --- a/docs/open-source/graph_memory/overview.mdx +++ b/docs/open-source/graph_memory/overview.mdx @@ -285,7 +285,7 @@ m = Memory.from_config(config_dict=config) - For issues related to authentication, refer to the [boto3 client configuration options](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html). -- For more details on how to connect, configure, and use the graph_memory graph store, see the [Neptune Analytics example notebook](examples/graph-db-demo/neptune-analytics-example.ipynb). +- For more details on how to connect, configure, and use the graph_memory graph store, see the Neptune Analytics example in our [AWS example guide](/examples/aws_example#aws-bedrock-and-aoss). ### Initialize Kuzu diff --git a/docs/platform/features/platform-overview.mdx b/docs/platform/features/platform-overview.mdx index 2163f7078..8ccf2c3b3 100644 --- a/docs/platform/features/platform-overview.mdx +++ b/docs/platform/features/platform-overview.mdx @@ -9,34 +9,34 @@ Learn about the key features and capabilities that make Mem0 a powerful platform ## Core Features - + Superior search results using state-of-the-art algorithms, including keyword search, reranking, and filtering capabilities. - + Only send your latest conversation history - we automatically retrieve the rest and generate properly contextualized memories. - + Process and analyze various types of content including images. - + Customize and curate stored memories to focus on relevant information while excluding unnecessary data, enabling improved accuracy, privacy control, and resource efficiency. - + Create and manage custom categories to organize memories based on your specific needs and requirements. - + Define specific guidelines for your project to ensure consistent handling of information and requirements. - + Tailor the behavior of your Mem0 instance with custom prompts for specific use cases or domains. - + Asynchronous client for non-blocking operations and high concurrency applications. - + Export memories in structured formats using customizable Pydantic schemas. - + Add memories in the form of nodes and edges in a graph database and search for related memories. diff --git a/docs/v0x/components/embedders/config.mdx b/docs/v0x/components/embedders/config.mdx new file mode 100644 index 000000000..dc805e8a0 --- /dev/null +++ b/docs/v0x/components/embedders/config.mdx @@ -0,0 +1,101 @@ +--- +title: Configurations +icon: "gear" +iconType: "solid" +--- + + +Config in mem0 is a dictionary that specifies the settings for your embedding models. It allows you to customize the behavior and connection details of your chosen embedder. + +## How to define configurations? + +The config is defined as an object (or dictionary) with two main keys: +- `embedder`: Specifies the embedder provider and its configuration + - `provider`: The name of the embedder (e.g., "openai", "ollama") + - `config`: A nested object or dictionary containing provider-specific settings + + +## How to use configurations? + +Here's a general example of how to use the config with mem0: + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "sk-xx" + +config = { + "embedder": { + "provider": "your_chosen_provider", + "config": { + # Provider-specific settings go here + } + } +} + +m = Memory.from_config(config) +m.add("Your text here", user_id="user", metadata={"category": "example"}) +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + embedder: { + provider: 'openai', + config: { + apiKey: process.env.OPENAI_API_KEY || '', + model: 'text-embedding-3-small', + // Provider-specific settings go here + }, + }, +}; + +const memory = new Memory(config); +await memory.add("Your text here", { userId: "user", metadata: { category: "example" } }); +``` + + +## Why is Config Needed? + +Config is essential for: +1. Specifying which embedding model to use. +2. Providing necessary connection details (e.g., model, api_key, embedding_dims). +3. Ensuring proper initialization and connection to your chosen embedder. + +## Master List of All Params in Config + +Here's a comprehensive list of all parameters that can be used across different embedders: + + + +| Parameter | Description | Provider | +|-----------|-------------|----------| +| `model` | Embedding model to use | All | +| `api_key` | API key of the provider | All | +| `embedding_dims` | Dimensions of the embedding model | All | +| `http_client_proxies` | Allow proxy server settings | All | +| `ollama_base_url` | Base URL for the Ollama embedding model | Ollama | +| `model_kwargs` | Key-Value arguments for the Huggingface embedding model | Huggingface | +| `azure_kwargs` | Key-Value arguments for the AzureOpenAI embedding model | Azure OpenAI | +| `openai_base_url` | Base URL for OpenAI API | OpenAI | +| `vertex_credentials_json` | Path to the Google Cloud credentials JSON file for VertexAI | VertexAI | +| `memory_add_embedding_type` | The type of embedding to use for the add memory action | VertexAI | +| `memory_update_embedding_type` | The type of embedding to use for the update memory action | VertexAI | +| `memory_search_embedding_type` | The type of embedding to use for the search memory action | VertexAI | +| `lmstudio_base_url` | Base URL for LM Studio API | LM Studio | + + +| Parameter | Description | Provider | +|-----------|-------------|----------| +| `model` | Embedding model to use | All | +| `apiKey` | API key of the provider | All | +| `embeddingDims` | Dimensions of the embedding model | All | + + + +## Supported Embedding Models + +For detailed information on configuring specific embedders, please visit the [Embedding Models](./models) section. There you'll find information for each supported embedder with provider-specific usage examples and configuration details. diff --git a/docs/v0x/components/embedders/models/aws_bedrock.mdx b/docs/v0x/components/embedders/models/aws_bedrock.mdx new file mode 100644 index 000000000..389fa6559 --- /dev/null +++ b/docs/v0x/components/embedders/models/aws_bedrock.mdx @@ -0,0 +1,62 @@ +--- +title: AWS Bedrock +--- + +To use AWS Bedrock embedding models, you need to have the appropriate AWS credentials and permissions. The embeddings implementation relies on the `boto3` library. + +### Setup +- Ensure you have model access from the [AWS Bedrock Console](https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/modelaccess) +- Authenticate the boto3 client using a method described in the [AWS documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) +- Set up environment variables for authentication: + ```bash + export AWS_REGION=us-east-1 + export AWS_ACCESS_KEY_ID=your-access-key + export AWS_SECRET_ACCESS_KEY=your-secret-key + ``` + +### Usage + + +```python Python +import os +from mem0 import Memory + +# For LLM if needed +os.environ["OPENAI_API_KEY"] = "your-openai-api-key" + +# AWS credentials +os.environ["AWS_REGION"] = "us-west-2" +os.environ["AWS_ACCESS_KEY_ID"] = "your-access-key" +os.environ["AWS_SECRET_ACCESS_KEY"] = "your-secret-key" + +config = { + "embedder": { + "provider": "aws_bedrock", + "config": { + "model": "amazon.titan-embed-text-v2:0" + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice") +``` + + +### Config + +Here are the parameters available for configuring AWS Bedrock embedder: + + + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `model` | The name of the embedding model to use | `amazon.titan-embed-text-v1` | + + diff --git a/docs/v0x/components/embedders/models/azure_openai.mdx b/docs/v0x/components/embedders/models/azure_openai.mdx new file mode 100644 index 000000000..a095288fa --- /dev/null +++ b/docs/v0x/components/embedders/models/azure_openai.mdx @@ -0,0 +1,125 @@ +--- +title: Azure OpenAI +--- + +To use Azure OpenAI embedding models, set the `EMBEDDING_AZURE_OPENAI_API_KEY`, `EMBEDDING_AZURE_DEPLOYMENT`, `EMBEDDING_AZURE_ENDPOINT` and `EMBEDDING_AZURE_API_VERSION` environment variables. You can obtain the Azure OpenAI API key from the Azure. + +### Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["EMBEDDING_AZURE_OPENAI_API_KEY"] = "your-api-key" +os.environ["EMBEDDING_AZURE_DEPLOYMENT"] = "your-deployment-name" +os.environ["EMBEDDING_AZURE_ENDPOINT"] = "your-api-base-url" +os.environ["EMBEDDING_AZURE_API_VERSION"] = "version-to-use" + +os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM + + +config = { + "embedder": { + "provider": "azure_openai", + "config": { + "model": "text-embedding-3-large" + "azure_kwargs": { + "api_version": "", + "azure_deployment": "", + "azure_endpoint": "", + "api_key": "", + "default_headers": { + "CustomHeader": "your-custom-header", + } + } + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="john") +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + embedder: { + provider: "azure_openai", + config: { + model: "text-embedding-3-large", + modelProperties: { + endpoint: "your-api-base-url", + deployment: "your-deployment-name", + apiVersion: "version-to-use", + } + } + } +} + +const memory = new Memory(config); + +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] + +await memory.add(messages, { userId: "john" }); +``` + + +As an alternative to using an API key, the Azure Identity credential chain can be used to authenticate with [Azure OpenAI role-based security](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/role-based-access-control). + + If an API key is provided, it will be used for authentication over an Azure Identity + +Below is a sample configuration for using Mem0 with Azure OpenAI and Azure Identity: + +```python +import os +from mem0 import Memory +# You can set the values directly in the config dictionary or use environment variables + +os.environ["LLM_AZURE_DEPLOYMENT"] = "your-deployment-name" +os.environ["LLM_AZURE_ENDPOINT"] = "your-api-base-url" +os.environ["LLM_AZURE_API_VERSION"] = "version-to-use" + +config = { + "llm": { + "provider": "azure_openai_structured", + "config": { + "model": "your-deployment-name", + "temperature": 0.1, + "max_tokens": 2000, + "azure_kwargs": { + "azure_deployment": "", + "api_version": "", + "azure_endpoint": "", + "default_headers": { + "CustomHeader": "your-custom-header", + } + } + } + } +} +``` + +Refer to [Azure Identity troubleshooting tips](https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/identity/azure-identity/TROUBLESHOOTING.md#troubleshoot-environmentcredential-authentication-issues) for setting up an Azure Identity credential. + +### Config + +Here are the parameters available for configuring Azure OpenAI embedder: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `model` | The name of the embedding model to use | `text-embedding-3-small` | +| `embedding_dims` | Dimensions of the embedding model | `1536` | +| `azure_kwargs` | The Azure OpenAI configs | `config_keys` | diff --git a/docs/v0x/components/embedders/models/google_AI.mdx b/docs/v0x/components/embedders/models/google_AI.mdx new file mode 100644 index 000000000..9efd41b2e --- /dev/null +++ b/docs/v0x/components/embedders/models/google_AI.mdx @@ -0,0 +1,69 @@ +--- +title: Google AI +--- + +To use Google AI embedding models, set the `GOOGLE_API_KEY` environment variables. You can obtain the Gemini API key from [here](https://aistudio.google.com/app/apikey). + +### Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["GOOGLE_API_KEY"] = "key" +os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM + +config = { + "embedder": { + "provider": "gemini", + "config": { + "model": "models/text-embedding-004", + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="john") +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + embedder: { + provider: 'google', + config: { + apiKey: process.env.GOOGLE_API_KEY || '', + model: 'text-embedding-004', + // The output dimensionality is fixed at 768 for Google AI embeddings + }, + }, +}; + +const memory = new Memory(config); +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +await memory.add(messages, { userId: "john" }); +``` + + +### Config + +Here are the parameters available for configuring Gemini embedder: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `model` | The name of the embedding model to use | `models/text-embedding-004` | +| `embedding_dims` | Dimensions of the embedding model (output_dimensionality will be considered as embedding_dims, so please set embedding_dims accordingly) | `768` | +| `api_key` | The Google API key | `None` | diff --git a/docs/v0x/components/embedders/models/huggingface.mdx b/docs/v0x/components/embedders/models/huggingface.mdx new file mode 100644 index 000000000..1e9f53049 --- /dev/null +++ b/docs/v0x/components/embedders/models/huggingface.mdx @@ -0,0 +1,75 @@ +--- +title: Hugging Face +--- + +You can use embedding models from Huggingface to run Mem0 locally. + +### Usage + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM + +config = { + "embedder": { + "provider": "huggingface", + "config": { + "model": "multi-qa-MiniLM-L6-cos-v1" + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="john") +``` + +### Using Text Embeddings Inference (TEI) + +You can also use Hugging Face's Text Embeddings Inference service for faster and more efficient embeddings: + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM + +# Using HuggingFace Text Embeddings Inference API +config = { + "embedder": { + "provider": "huggingface", + "config": { + "huggingface_base_url": "http://localhost:3000/v1" + } + } +} + +m = Memory.from_config(config) +m.add("This text will be embedded using the TEI service.", user_id="john") +``` + +To run the TEI service, you can use Docker: + +```bash +docker run -d -p 3000:80 -v huggingfacetei:/data --platform linux/amd64 \ + ghcr.io/huggingface/text-embeddings-inference:cpu-1.6 \ + --model-id BAAI/bge-small-en-v1.5 +``` + +### Config + +Here are the parameters available for configuring Huggingface embedder: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `model` | The name of the model to use | `multi-qa-MiniLM-L6-cos-v1` | +| `embedding_dims` | Dimensions of the embedding model | `selected_model_dimensions` | +| `model_kwargs` | Additional arguments for the model | `None` | +| `huggingface_base_url` | URL to connect to Text Embeddings Inference (TEI) API | `None` | \ No newline at end of file diff --git a/docs/v0x/components/embedders/models/langchain.mdx b/docs/v0x/components/embedders/models/langchain.mdx new file mode 100644 index 000000000..74ad18573 --- /dev/null +++ b/docs/v0x/components/embedders/models/langchain.mdx @@ -0,0 +1,196 @@ +--- +title: LangChain +--- + +Mem0 supports LangChain as a provider to access a wide range of embedding models. LangChain is a framework for developing applications powered by language models, making it easy to integrate various embedding providers through a consistent interface. + +For a complete list of available embedding models supported by LangChain, refer to the [LangChain Text Embedding documentation](https://python.langchain.com/docs/integrations/text_embedding/). + +## Usage + + +```python Python +import os +from mem0 import Memory +from langchain_openai import OpenAIEmbeddings + +# Set necessary environment variables for your chosen LangChain provider +os.environ["OPENAI_API_KEY"] = "your-api-key" + +# Initialize a LangChain embeddings model directly +openai_embeddings = OpenAIEmbeddings( + model="text-embedding-3-small", + dimensions=1536 +) + +# Pass the initialized model to the config +config = { + "embedder": { + "provider": "langchain", + "config": { + "model": openai_embeddings + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; +import { OpenAIEmbeddings } from "@langchain/openai"; + +// Initialize a LangChain embeddings model directly +const openaiEmbeddings = new OpenAIEmbeddings({ + modelName: "text-embedding-3-small", + dimensions: 1536, + apiKey: process.env.OPENAI_API_KEY, +}); + +const config = { + embedder: { + provider: 'langchain', + config: { + model: openaiEmbeddings, + }, + }, +}; + +const memory = new Memory(config); +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +await memory.add(messages, { userId: "alice", metadata: { category: "movies" } }); +``` + + +## Supported LangChain Embedding Providers + +LangChain supports a wide range of embedding providers, including: + +- OpenAI (`OpenAIEmbeddings`) +- Cohere (`CohereEmbeddings`) +- Google (`VertexAIEmbeddings`) +- Hugging Face (`HuggingFaceEmbeddings`) +- Sentence Transformers (`HuggingFaceEmbeddings`) +- Azure OpenAI (`AzureOpenAIEmbeddings`) +- Ollama (`OllamaEmbeddings`) +- Together (`TogetherEmbeddings`) +- And many more + +You can use any of these model instances directly in your configuration. For a complete and up-to-date list of available embedding providers, refer to the [LangChain Text Embedding documentation](https://python.langchain.com/docs/integrations/text_embedding/). + +## Provider-Specific Configuration + +When using LangChain as an embedder provider, you'll need to: + +1. Set the appropriate environment variables for your chosen embedding provider +2. Import and initialize the specific model class you want to use +3. Pass the initialized model instance to the config + +### Examples with Different Providers + + +#### HuggingFace Embeddings + +```python Python +from langchain_huggingface import HuggingFaceEmbeddings + +# Initialize a HuggingFace embeddings model +hf_embeddings = HuggingFaceEmbeddings( + model_name="BAAI/bge-small-en-v1.5", + encode_kwargs={"normalize_embeddings": True} +) + +config = { + "embedder": { + "provider": "langchain", + "config": { + "model": hf_embeddings + } + } +} +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; +import { HuggingFaceEmbeddings } from "@langchain/community/embeddings/hf"; + +// Initialize a HuggingFace embeddings model +const hfEmbeddings = new HuggingFaceEmbeddings({ + modelName: "BAAI/bge-small-en-v1.5", + encode: { + normalize_embeddings: true, + }, +}); + +const config = { + embedder: { + provider: 'langchain', + config: { + model: hfEmbeddings, + }, + }, +}; +``` + + + +#### Ollama Embeddings + +```python Python +from langchain_ollama import OllamaEmbeddings + +# Initialize an Ollama embeddings model +ollama_embeddings = OllamaEmbeddings( + model="nomic-embed-text" +) + +config = { + "embedder": { + "provider": "langchain", + "config": { + "model": ollama_embeddings + } + } +} +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; +import { OllamaEmbeddings } from "@langchain/community/embeddings/ollama"; + +// Initialize an Ollama embeddings model +const ollamaEmbeddings = new OllamaEmbeddings({ + model: "nomic-embed-text", + baseUrl: "http://localhost:11434", // Ollama server URL +}); + +const config = { + embedder: { + provider: 'langchain', + config: { + model: ollamaEmbeddings, + }, + }, +}; +``` + + + + Make sure to install the necessary LangChain packages and any provider-specific dependencies. + + +## Config + +All available parameters for the `langchain` embedder config are present in [Master List of All Params in Config](../config). diff --git a/docs/v0x/components/embedders/models/lmstudio.mdx b/docs/v0x/components/embedders/models/lmstudio.mdx new file mode 100644 index 000000000..bc767b076 --- /dev/null +++ b/docs/v0x/components/embedders/models/lmstudio.mdx @@ -0,0 +1,38 @@ +You can use embedding models from LM Studio to run Mem0 locally. + +### Usage + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM + +config = { + "embedder": { + "provider": "lmstudio", + "config": { + "model": "nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf" + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="john") +``` + +### Config + +Here are the parameters available for configuring Ollama embedder: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `model` | The name of the OpenAI model to use | `nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf` | +| `embedding_dims` | Dimensions of the embedding model | `1536` | +| `lmstudio_base_url` | Base URL for LM Studio connection | `http://localhost:1234/v1` | \ No newline at end of file diff --git a/docs/v0x/components/embedders/models/ollama.mdx b/docs/v0x/components/embedders/models/ollama.mdx new file mode 100644 index 000000000..4e1a4d331 --- /dev/null +++ b/docs/v0x/components/embedders/models/ollama.mdx @@ -0,0 +1,73 @@ +You can use embedding models from Ollama to run Mem0 locally. + +### Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM + +config = { + "embedder": { + "provider": "ollama", + "config": { + "model": "mxbai-embed-large" + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="john") +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + embedder: { + provider: 'ollama', + config: { + model: 'nomic-embed-text:latest', // or any other Ollama embedding model + url: 'http://localhost:11434', // Ollama server URL + }, + }, +}; + +const memory = new Memory(config); +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +await memory.add(messages, { userId: "john" }); +``` + + +### Config + +Here are the parameters available for configuring Ollama embedder: + + + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `model` | The name of the Ollama model to use | `nomic-embed-text` | +| `embedding_dims` | Dimensions of the embedding model | `512` | +| `ollama_base_url` | Base URL for ollama connection | `None` | + + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `model` | The name of the Ollama model to use | `nomic-embed-text:latest` | +| `url` | Base URL for Ollama server | `http://localhost:11434` | + + \ No newline at end of file diff --git a/docs/v0x/components/embedders/models/openai.mdx b/docs/v0x/components/embedders/models/openai.mdx new file mode 100644 index 000000000..68be78a97 --- /dev/null +++ b/docs/v0x/components/embedders/models/openai.mdx @@ -0,0 +1,72 @@ +--- +title: OpenAI +--- + +To use OpenAI embedding models, set the `OPENAI_API_KEY` environment variable. You can obtain the OpenAI API key from the [OpenAI Platform](https://platform.openai.com/account/api-keys). + +### Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your_api_key" + +config = { + "embedder": { + "provider": "openai", + "config": { + "model": "text-embedding-3-large" + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="john") +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + embedder: { + provider: 'openai', + config: { + apiKey: 'your-openai-api-key', + model: 'text-embedding-3-large', + }, + }, +}; + +const memory = new Memory(config); +await memory.add("I'm visiting Paris", { userId: "john" }); +``` + + +### Config + +Here are the parameters available for configuring OpenAI embedder: + + + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `model` | The name of the embedding model to use | `text-embedding-3-small` | +| `embedding_dims` | Dimensions of the embedding model | `1536` | +| `api_key` | The OpenAI API key | `None` | + + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `model` | The name of the embedding model to use | `text-embedding-3-small` | +| `embeddingDims` | Dimensions of the embedding model | `1536` | +| `apiKey` | The OpenAI API key | `None` | + + diff --git a/docs/v0x/components/embedders/models/together.mdx b/docs/v0x/components/embedders/models/together.mdx new file mode 100644 index 000000000..9f1695c3c --- /dev/null +++ b/docs/v0x/components/embedders/models/together.mdx @@ -0,0 +1,45 @@ +--- +title: Together +--- + +To use Together embedding models, set the `TOGETHER_API_KEY` environment variable. You can obtain the Together API key from the [Together Platform](https://api.together.xyz/settings/api-keys). + +### Usage + + The `embedding_model_dims` parameter for `vector_store` should be set to `768` for Together embedder. + +```python +import os +from mem0 import Memory + +os.environ["TOGETHER_API_KEY"] = "your_api_key" +os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM + +config = { + "embedder": { + "provider": "together", + "config": { + "model": "togethercomputer/m2-bert-80M-8k-retrieval" + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="john") +``` + +### Config + +Here are the parameters available for configuring Together embedder: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `model` | The name of the embedding model to use | `togethercomputer/m2-bert-80M-8k-retrieval` | +| `embedding_dims` | Dimensions of the embedding model | `768` | +| `api_key` | The Together API key | `None` | diff --git a/docs/v0x/components/embedders/models/vertexai.mdx b/docs/v0x/components/embedders/models/vertexai.mdx new file mode 100644 index 000000000..88cc08a3e --- /dev/null +++ b/docs/v0x/components/embedders/models/vertexai.mdx @@ -0,0 +1,55 @@ +### Vertex AI + +To use Google Cloud's Vertex AI for text embedding models, set the `GOOGLE_APPLICATION_CREDENTIALS` environment variable to point to the path of your service account's credentials JSON file. These credentials can be created in the [Google Cloud Console](https://console.cloud.google.com/). + +### Usage + +```python +import os +from mem0 import Memory + +# Set the path to your Google Cloud credentials JSON file +os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "/path/to/your/credentials.json" +os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM + +config = { + "embedder": { + "provider": "vertexai", + "config": { + "model": "text-embedding-004", + "memory_add_embedding_type": "RETRIEVAL_DOCUMENT", + "memory_update_embedding_type": "RETRIEVAL_DOCUMENT", + "memory_search_embedding_type": "RETRIEVAL_QUERY" + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="john") +``` +The embedding types can be one of the following: +- SEMANTIC_SIMILARITY +- CLASSIFICATION +- CLUSTERING +- RETRIEVAL_DOCUMENT, RETRIEVAL_QUERY, QUESTION_ANSWERING, FACT_VERIFICATION +- CODE_RETRIEVAL_QUERY +Check out the [Vertex AI documentation](https://cloud.google.com/vertex-ai/generative-ai/docs/embeddings/task-types#supported_task_types) for more information. + +### Config + +Here are the parameters available for configuring the Vertex AI embedder: + +| Parameter | Description | Default Value | +| ------------------------- | ------------------------------------------------ | -------------------- | +| `model` | The name of the Vertex AI embedding model to use | `text-embedding-004` | +| `vertex_credentials_json` | Path to the Google Cloud credentials JSON file | `None` | +| `embedding_dims` | Dimensions of the embedding model | `256` | +| `memory_add_embedding_type` | The type of embedding to use for the add memory action | `RETRIEVAL_DOCUMENT` | +| `memory_update_embedding_type` | The type of embedding to use for the update memory action | `RETRIEVAL_DOCUMENT` | +| `memory_search_embedding_type` | The type of embedding to use for the search memory action | `RETRIEVAL_QUERY` | diff --git a/docs/v0x/components/embedders/overview.mdx b/docs/v0x/components/embedders/overview.mdx new file mode 100644 index 000000000..4a5990b61 --- /dev/null +++ b/docs/v0x/components/embedders/overview.mdx @@ -0,0 +1,34 @@ +--- +title: Overview +icon: "info" +iconType: "solid" +--- + +Mem0 offers support for various embedding models, allowing users to choose the one that best suits their needs. + +## Supported Embedders + +See the list of supported embedders below. + + + The following embedders are supported in the Python implementation. The TypeScript implementation currently only supports OpenAI. + + + + + + + + + + + + + + + +## Usage + +To utilize a embedder, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `OpenAI` will be used as the embedder. + +For a comprehensive list of available parameters for embedder configuration, please refer to [Config](./config). diff --git a/docs/v0x/components/llms/config.mdx b/docs/v0x/components/llms/config.mdx new file mode 100644 index 000000000..08332cb11 --- /dev/null +++ b/docs/v0x/components/llms/config.mdx @@ -0,0 +1,137 @@ +--- +title: Configurations +icon: "gear" +iconType: "solid" +--- + +## How to define configurations? + + + + The `config` is defined as a Python dictionary with two main keys: + - `llm`: Specifies the llm provider and its configuration + - `provider`: The name of the llm (e.g., "openai", "groq") + - `config`: A nested dictionary containing provider-specific settings + + + The `config` is defined as a TypeScript object with these keys: + - `llm`: Specifies the LLM provider and its configuration (required) + - `provider`: The name of the LLM (e.g., "openai", "groq") + - `config`: A nested object containing provider-specific settings + - `embedder`: Specifies the embedder provider and its configuration (optional) + - `vectorStore`: Specifies the vector store provider and its configuration (optional) + - `historyDbPath`: Path to the history database file (optional) + + + +### Config Values Precedence + +Config values are applied in the following order of precedence (from highest to lowest): + +1. Values explicitly set in the `config` object/dictionary +2. Environment variables (e.g., `OPENAI_API_KEY`, `OPENAI_BASE_URL`) +3. Default values defined in the LLM implementation + +This means that values specified in the `config` will override corresponding environment variables, which in turn override default values. + +## How to Use Config + +Here's a general example of how to use the config with Mem0: + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "sk-xx" # for embedder + +config = { + "llm": { + "provider": "your_chosen_provider", + "config": { + # Provider-specific settings go here + } + } +} + +m = Memory.from_config(config) +m.add("Your text here", user_id="user", metadata={"category": "example"}) + +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +// Minimal configuration with just the LLM settings +const config = { + llm: { + provider: 'your_chosen_provider', + config: { + // Provider-specific settings go here + } + } +}; + +const memory = new Memory(config); +await memory.add("Your text here", { userId: "user123", metadata: { category: "example" } }); +``` + + + +## Why is Config Needed? + +Config is essential for: +1. Specifying which LLM to use. +2. Providing necessary connection details (e.g., model, api_key, temperature). +3. Ensuring proper initialization and connection to your chosen LLM. + +## Master List of All Params in Config + +Here's a comprehensive list of all parameters that can be used across different LLMs: + + + + | Parameter | Description | Provider | + |----------------------|-----------------------------------------------|-------------------| + | `model` | Embedding model to use | All | + | `temperature` | Temperature of the model | All | + | `api_key` | API key to use | All | + | `max_tokens` | Tokens to generate | All | + | `top_p` | Probability threshold for nucleus sampling | All | + | `top_k` | Number of highest probability tokens to keep | All | + | `http_client_proxies`| Allow proxy server settings | AzureOpenAI | + | `models` | List of models | Openrouter | + | `route` | Routing strategy | Openrouter | + | `openrouter_base_url`| Base URL for Openrouter API | Openrouter | + | `site_url` | Site URL | Openrouter | + | `app_name` | Application name | Openrouter | + | `ollama_base_url` | Base URL for Ollama API | Ollama | + | `openai_base_url` | Base URL for OpenAI API | OpenAI | + | `azure_kwargs` | Azure LLM args for initialization | AzureOpenAI | + | `deepseek_base_url` | Base URL for DeepSeek API | DeepSeek | + | `xai_base_url` | Base URL for XAI API | XAI | + | `sarvam_base_url` | Base URL for Sarvam API | Sarvam | + | `reasoning_effort` | Reasoning level (low, medium, high) | Sarvam | + | `frequency_penalty` | Penalize frequent tokens (-2.0 to 2.0) | Sarvam | + | `presence_penalty` | Penalize existing tokens (-2.0 to 2.0) | Sarvam | + | `seed` | Seed for deterministic sampling | Sarvam | + | `stop` | Stop sequences (max 4) | Sarvam | + | `lmstudio_base_url` | Base URL for LM Studio API | LM Studio | + | `response_callback` | LLM response callback function | OpenAI | + + + | Parameter | Description | Provider | + |----------------------|-----------------------------------------------|-------------------| + | `model` | Embedding model to use | All | + | `temperature` | Temperature of the model | All | + | `apiKey` | API key to use | All | + | `maxTokens` | Tokens to generate | All | + | `topP` | Probability threshold for nucleus sampling | All | + | `topK` | Number of highest probability tokens to keep | All | + | `openaiBaseUrl` | Base URL for OpenAI API | OpenAI | + + + +## Supported LLMs + +For detailed information on configuring specific LLMs, please visit the [LLMs](./models) section. There you'll find information for each supported LLM with provider-specific usage examples and configuration details. diff --git a/docs/v0x/components/llms/models/anthropic.mdx b/docs/v0x/components/llms/models/anthropic.mdx new file mode 100644 index 000000000..688d85050 --- /dev/null +++ b/docs/v0x/components/llms/models/anthropic.mdx @@ -0,0 +1,67 @@ +--- +title: Anthropic +--- + + +To use Anthropic's models, please set the `ANTHROPIC_API_KEY` which you find on their [Account Settings Page](https://console.anthropic.com/account/keys). + +## Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model +os.environ["ANTHROPIC_API_KEY"] = "your-api-key" + +config = { + "llm": { + "provider": "anthropic", + "config": { + "model": "claude-sonnet-4-20250514", + "temperature": 0.1, + "max_tokens": 2000, + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + llm: { + provider: 'anthropic', + config: { + apiKey: process.env.ANTHROPIC_API_KEY || '', + model: 'claude-sonnet-4-20250514', + temperature: 0.1, + maxTokens: 2000, + }, + }, +}; + +const memory = new Memory(config); +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +await memory.add(messages, { userId: "alice", metadata: { category: "movies" } }); +``` + + +## Config + +All available parameters for the `anthropic` config are present in [Master List of All Params in Config](../config). \ No newline at end of file diff --git a/docs/v0x/components/llms/models/aws_bedrock.mdx b/docs/v0x/components/llms/models/aws_bedrock.mdx new file mode 100644 index 000000000..ae1287b83 --- /dev/null +++ b/docs/v0x/components/llms/models/aws_bedrock.mdx @@ -0,0 +1,43 @@ +--- +title: AWS Bedrock +--- + +### Setup +- Before using the AWS Bedrock LLM, make sure you have the appropriate model access from [Bedrock Console](https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/modelaccess). +- You will also need to authenticate the `boto3` client by using a method in the [AWS documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#configuring-credentials) +- You will have to export `AWS_REGION`, `AWS_ACCESS_KEY`, and `AWS_SECRET_ACCESS_KEY` to set environment variables. + +### Usage + +```python +import os +from mem0 import Memory + +os.environ['AWS_REGION'] = 'us-west-2' +os.environ["AWS_ACCESS_KEY_ID"] = "xx" +os.environ["AWS_SECRET_ACCESS_KEY"] = "xx" + +config = { + "llm": { + "provider": "aws_bedrock", + "config": { + "model": "anthropic.claude-3-5-haiku-20241022-v1:0", + "temperature": 0.2, + "max_tokens": 2000, + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +### Config + +All available parameters for the `aws_bedrock` config are present in [Master List of All Params in Config](../config). \ No newline at end of file diff --git a/docs/v0x/components/llms/models/azure_openai.mdx b/docs/v0x/components/llms/models/azure_openai.mdx new file mode 100644 index 000000000..02a0d351e --- /dev/null +++ b/docs/v0x/components/llms/models/azure_openai.mdx @@ -0,0 +1,161 @@ +--- +title: Azure OpenAI +--- + + Mem0 Now Supports Azure OpenAI Models in TypeScript SDK + +To use Azure OpenAI models, you have to set the `LLM_AZURE_OPENAI_API_KEY`, `LLM_AZURE_ENDPOINT`, `LLM_AZURE_DEPLOYMENT` and `LLM_AZURE_API_VERSION` environment variables. You can obtain the Azure API key from the [Azure](https://azure.microsoft.com/). + +Optionally, you can use Azure Identity to authenticate with Azure OpenAI, which allows you to use managed identities or service principals for production and Azure CLI login for development instead of an API key. If an Azure Identity is to be used, ***do not*** set the `LLM_AZURE_OPENAI_API_KEY` environment variable or the api_key in the config dictionary. + +> **Note**: The following are currently unsupported with reasoning models `Parallel tool calling`,`temperature`, `top_p`, `presence_penalty`, `frequency_penalty`, `logprobs`, `top_logprobs`, `logit_bias`, `max_tokens` + + +## Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model + +os.environ["LLM_AZURE_OPENAI_API_KEY"] = "your-api-key" +os.environ["LLM_AZURE_DEPLOYMENT"] = "your-deployment-name" +os.environ["LLM_AZURE_ENDPOINT"] = "your-api-base-url" +os.environ["LLM_AZURE_API_VERSION"] = "version-to-use" + +config = { + "llm": { + "provider": "azure_openai", + "config": { + "model": "your-deployment-name", + "temperature": 0.1, + "max_tokens": 2000, + "azure_kwargs": { + "azure_deployment": "", + "api_version": "", + "azure_endpoint": "", + "api_key": "", + "default_headers": { + "CustomHeader": "your-custom-header", + } + } + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + llm: { + provider: 'azure_openai', + config: { + apiKey: process.env.AZURE_OPENAI_API_KEY || '', + modelProperties: { + endpoint: 'https://your-api-base-url', + deployment: 'your-deployment-name', + modelName: 'your-model-name', + apiVersion: 'version-to-use', + // Any other parameters you want to pass to the Azure OpenAI API + }, + }, + }, +}; + +const memory = new Memory(config); +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +await memory.add(messages, { userId: "alice", metadata: { category: "movies" } }); +``` + + + +We also support the new [OpenAI structured-outputs](https://platform.openai.com/docs/guides/structured-outputs/introduction) model. Typescript SDK does not support the `azure_openai_structured` model yet. + +```python +import os +from mem0 import Memory + +os.environ["LLM_AZURE_OPENAI_API_KEY"] = "your-api-key" +os.environ["LLM_AZURE_DEPLOYMENT"] = "your-deployment-name" +os.environ["LLM_AZURE_ENDPOINT"] = "your-api-base-url" +os.environ["LLM_AZURE_API_VERSION"] = "version-to-use" + +config = { + "llm": { + "provider": "azure_openai_structured", + "config": { + "model": "your-deployment-name", + "temperature": 0.1, + "max_tokens": 2000, + "azure_kwargs": { + "azure_deployment": "", + "api_version": "", + "azure_endpoint": "", + "api_key": "", + "default_headers": { + "CustomHeader": "your-custom-header", + } + } + } + } +} +``` + +As an alternative to using an API key, the Azure Identity credential chain can be used to authenticate with [Azure OpenAI role-based security](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/role-based-access-control). + + If an API key is provided, it will be used for authentication over an Azure Identity + +Below is a sample configuration for using Mem0 with Azure OpenAI and Azure Identity: + +```python +import os +from mem0 import Memory +# You can set the values directly in the config dictionary or use environment variables + +os.environ["LLM_AZURE_DEPLOYMENT"] = "your-deployment-name" +os.environ["LLM_AZURE_ENDPOINT"] = "your-api-base-url" +os.environ["LLM_AZURE_API_VERSION"] = "version-to-use" + +config = { + "llm": { + "provider": "azure_openai_structured", + "config": { + "model": "your-deployment-name", + "temperature": 0.1, + "max_tokens": 2000, + "azure_kwargs": { + "azure_deployment": "", + "api_version": "", + "azure_endpoint": "", + "default_headers": { + "CustomHeader": "your-custom-header", + } + } + } + } +} +``` + +Refer to [Azure Identity troubleshooting tips](https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/identity/azure-identity/TROUBLESHOOTING.md#troubleshoot-environmentcredential-authentication-issues) for setting up an Azure Identity credential. + + +## Config + +All available parameters for the `azure_openai` config are present in [Master List of All Params in Config](../config). diff --git a/docs/v0x/components/llms/models/deepseek.mdx b/docs/v0x/components/llms/models/deepseek.mdx new file mode 100644 index 000000000..af1783a1c --- /dev/null +++ b/docs/v0x/components/llms/models/deepseek.mdx @@ -0,0 +1,55 @@ +--- +title: DeepSeek +--- + +To use DeepSeek LLM models, you have to set the `DEEPSEEK_API_KEY` environment variable. You can also optionally set `DEEPSEEK_API_BASE` if you need to use a different API endpoint (defaults to "https://api.deepseek.com"). + +## Usage + +```python +import os +from mem0 import Memory + +os.environ["DEEPSEEK_API_KEY"] = "your-api-key" +os.environ["OPENAI_API_KEY"] = "your-api-key" # for embedder model + +config = { + "llm": { + "provider": "deepseek", + "config": { + "model": "deepseek-chat", # default model + "temperature": 0.2, + "max_tokens": 2000, + "top_p": 1.0 + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +You can also configure the API base URL in the config: + +```python +config = { + "llm": { + "provider": "deepseek", + "config": { + "model": "deepseek-chat", + "deepseek_base_url": "https://your-custom-endpoint.com", + "api_key": "your-api-key" # alternatively to using environment variable + } + } +} +``` + +## Config + +All available parameters for the `deepseek` config are present in [Master List of All Params in Config](../config). \ No newline at end of file diff --git a/docs/v0x/components/llms/models/google_AI.mdx b/docs/v0x/components/llms/models/google_AI.mdx new file mode 100644 index 000000000..aad05d022 --- /dev/null +++ b/docs/v0x/components/llms/models/google_AI.mdx @@ -0,0 +1,74 @@ +--- +title: Google AI +--- + +To use the Gemini model, set the `GOOGLE_API_KEY` environment variable. You can obtain the Google/Gemini API key from [Google AI Studio](https://aistudio.google.com/app/apikey). + +> **Note:** As of the latest release, Mem0 uses the new `google.genai` SDK instead of the deprecated `google.generativeai`. All message formatting and model interaction now use the updated `types` module from `google.genai`. + +> **Note:** Some Gemini models are being deprecated and will retire soon. It is recommended to migrate to the latest stable models like `"gemini-2.0-flash-001"` or `"gemini-2.0-flash-lite-001"` to ensure ongoing support and improvements. + +## Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-openai-api-key" # Used for embedding model +os.environ["GOOGLE_API_KEY"] = "your-gemini-api-key" + +config = { + "llm": { + "provider": "gemini", + "config": { + "model": "gemini-2.0-flash-001", + "temperature": 0.2, + "max_tokens": 2000, + "top_p": 1.0 + } + } +} + +m = Memory.from_config(config) + +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thrillers, but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thrillers and suggest sci-fi movies instead."} +] + +m.add(messages, user_id="alice", metadata={"category": "movies"}) + +``` +```typescript TypeScript +import { Memory } from "mem0ai/oss"; + +const config = { + llm: { + // You can also use "google" as provider ( for backward compatibility ) + provider: "gemini", + config: { + model: "gemini-2.0-flash-001", + temperature: 0.1 + } + } +} + +const memory = new Memory(config); + +const messages = [ + { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" }, + { role: "assistant", content: "How about thriller movies? They can be quite engaging." }, + { role: "user", content: "I’m not a big fan of thrillers, but I love sci-fi movies." }, + { role: "assistant", content: "Got it! I'll avoid thrillers and suggest sci-fi movies instead." } +] + +await memory.add(messages, { userId: "alice", metadata: { category: "movies" } }); +``` + + +## Config + +All available parameters for the `Gemini` config are present in [Master List of All Params in Config](../config). \ No newline at end of file diff --git a/docs/v0x/components/llms/models/groq.mdx b/docs/v0x/components/llms/models/groq.mdx new file mode 100644 index 000000000..d8f0727ce --- /dev/null +++ b/docs/v0x/components/llms/models/groq.mdx @@ -0,0 +1,68 @@ +--- +title: Groq +--- + +[Groq](https://groq.com/) is the creator of the world's first Language Processing Unit (LPU), providing exceptional speed performance for AI workloads running on their LPU Inference Engine. + +In order to use LLMs from Groq, go to their [platform](https://console.groq.com/keys) and get the API key. Set the API key as `GROQ_API_KEY` environment variable to use the model as given below in the example. + +## Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model +os.environ["GROQ_API_KEY"] = "your-api-key" + +config = { + "llm": { + "provider": "groq", + "config": { + "model": "mixtral-8x7b-32768", + "temperature": 0.1, + "max_tokens": 2000, + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + llm: { + provider: 'groq', + config: { + apiKey: process.env.GROQ_API_KEY || '', + model: 'mixtral-8x7b-32768', + temperature: 0.1, + maxTokens: 1000, + }, + }, +}; + +const memory = new Memory(config); +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +await memory.add(messages, { userId: "alice", metadata: { category: "movies" } }); +``` + + +## Config + +All available parameters for the `groq` config are present in [Master List of All Params in Config](../config). \ No newline at end of file diff --git a/docs/v0x/components/llms/models/langchain.mdx b/docs/v0x/components/llms/models/langchain.mdx new file mode 100644 index 000000000..624d86425 --- /dev/null +++ b/docs/v0x/components/llms/models/langchain.mdx @@ -0,0 +1,109 @@ +--- +title: LangChain +--- + + +Mem0 supports LangChain as a provider to access a wide range of LLM models. LangChain is a framework for developing applications powered by language models, making it easy to integrate various LLM providers through a consistent interface. + +For a complete list of available chat models supported by LangChain, refer to the [LangChain Chat Models documentation](https://python.langchain.com/docs/integrations/chat). + +## Usage + + +```python Python +import os +from mem0 import Memory +from langchain_openai import ChatOpenAI + +# Set necessary environment variables for your chosen LangChain provider +os.environ["OPENAI_API_KEY"] = "your-api-key" + +# Initialize a LangChain model directly +openai_model = ChatOpenAI( + model="gpt-4o", + temperature=0.2, + max_tokens=2000 +) + +# Pass the initialized model to the config +config = { + "llm": { + "provider": "langchain", + "config": { + "model": openai_model + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; +import { ChatOpenAI } from "@langchain/openai"; + +// Initialize a LangChain model directly +const openaiModel = new ChatOpenAI({ + modelName: "gpt-4", + temperature: 0.2, + maxTokens: 2000, + apiKey: process.env.OPENAI_API_KEY, +}); + +const config = { + llm: { + provider: 'langchain', + config: { + model: openaiModel, + }, + }, +}; + +const memory = new Memory(config); +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +await memory.add(messages, { userId: "alice", metadata: { category: "movies" } }); +``` + + +## Supported LangChain Providers + +LangChain supports a wide range of LLM providers, including: + +- OpenAI (`ChatOpenAI`) +- Anthropic (`ChatAnthropic`) +- Google (`ChatGoogleGenerativeAI`, `ChatGooglePalm`) +- Mistral (`ChatMistralAI`) +- Ollama (`ChatOllama`) +- Azure OpenAI (`AzureChatOpenAI`) +- HuggingFace (`HuggingFaceChatEndpoint`) +- And many more + +You can use any of these model instances directly in your configuration. For a complete and up-to-date list of available providers, refer to the [LangChain Chat Models documentation](https://python.langchain.com/docs/integrations/chat). + +## Provider-Specific Configuration + +When using LangChain as a provider, you'll need to: + +1. Set the appropriate environment variables for your chosen LLM provider +2. Import and initialize the specific model class you want to use +3. Pass the initialized model instance to the config + + + Make sure to install the necessary LangChain packages and any provider-specific dependencies. + + +## Config + +All available parameters for the `langchain` config are present in [Master List of All Params in Config](../config). diff --git a/docs/v0x/components/llms/models/litellm.mdx b/docs/v0x/components/llms/models/litellm.mdx new file mode 100644 index 000000000..d66669f86 --- /dev/null +++ b/docs/v0x/components/llms/models/litellm.mdx @@ -0,0 +1,34 @@ +[Litellm](https://litellm.vercel.app/docs/) is compatible with over 100 large language models (LLMs), all using a standardized input/output format. You can explore the [available models](https://litellm.vercel.app/docs/providers) to use with Litellm. Ensure you set the `API_KEY` for the model you choose to use. + +## Usage + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" + +config = { + "llm": { + "provider": "litellm", + "config": { + "model": "gpt-4o-mini", + "temperature": 0.2, + "max_tokens": 2000, + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +## Config + +All available parameters for the `litellm` config are present in [Master List of All Params in Config](../config). \ No newline at end of file diff --git a/docs/v0x/components/llms/models/lmstudio.mdx b/docs/v0x/components/llms/models/lmstudio.mdx new file mode 100644 index 000000000..cb4281235 --- /dev/null +++ b/docs/v0x/components/llms/models/lmstudio.mdx @@ -0,0 +1,83 @@ +--- +title: LM Studio +--- + +To use LM Studio with Mem0, you'll need to have LM Studio running locally with its server enabled. LM Studio provides a way to run local LLMs with an OpenAI-compatible API. + +## Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model + +config = { + "llm": { + "provider": "lmstudio", + "config": { + "model": "lmstudio-community/Meta-Llama-3.1-70B-Instruct-GGUF/Meta-Llama-3.1-70B-Instruct-IQ2_M.gguf", + "temperature": 0.2, + "max_tokens": 2000, + "lmstudio_base_url": "http://localhost:1234/v1", # default LM Studio API URL + "lmstudio_response_format": {"type": "json_schema", "json_schema": {"type": "object", "schema": {}}}, + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + + +### Running Completely Locally + +You can also use LM Studio for both LLM and embedding to run Mem0 entirely locally: + +```python +from mem0 import Memory + +# No external API keys needed! +config = { + "llm": { + "provider": "lmstudio" + }, + "embedder": { + "provider": "lmstudio" + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice123", metadata={"category": "movies"}) +``` + + + When using LM Studio for both LLM and embedding, make sure you have: + 1. An LLM model loaded for generating responses + 2. An embedding model loaded for vector embeddings + 3. The server enabled with the correct endpoints accessible + + + + To use LM Studio, you need to: + 1. Download and install [LM Studio](https://lmstudio.ai/) + 2. Start a local server from the "Server" tab + 3. Set the appropriate `lmstudio_base_url` in your configuration (default is usually http://localhost:1234/v1) + + +## Config + +All available parameters for the `lmstudio` config are present in [Master List of All Params in Config](../config). diff --git a/docs/v0x/components/llms/models/mistral_AI.mdx b/docs/v0x/components/llms/models/mistral_AI.mdx new file mode 100644 index 000000000..632d48772 --- /dev/null +++ b/docs/v0x/components/llms/models/mistral_AI.mdx @@ -0,0 +1,66 @@ +--- +title: Mistral AI +--- + +To use mistral's models, please obtain the Mistral AI api key from their [console](https://console.mistral.ai/). Set the `MISTRAL_API_KEY` environment variable to use the model as given below in the example. + +## Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model +os.environ["MISTRAL_API_KEY"] = "your-api-key" + +config = { + "llm": { + "provider": "litellm", + "config": { + "model": "open-mixtral-8x7b", + "temperature": 0.1, + "max_tokens": 2000, + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + llm: { + provider: 'mistral', + config: { + apiKey: process.env.MISTRAL_API_KEY || '', + model: 'mistral-tiny-latest', // Or 'mistral-small-latest', 'mistral-medium-latest', etc. + temperature: 0.1, + maxTokens: 2000, + }, + }, +}; + +const memory = new Memory(config); +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +await memory.add(messages, { userId: "alice", metadata: { category: "movies" } }); +``` + + +## Config + +All available parameters for the `litellm` config are present in [Master List of All Params in Config](../config). \ No newline at end of file diff --git a/docs/v0x/components/llms/models/ollama.mdx b/docs/v0x/components/llms/models/ollama.mdx new file mode 100644 index 000000000..9c0cd73cf --- /dev/null +++ b/docs/v0x/components/llms/models/ollama.mdx @@ -0,0 +1,60 @@ +You can use LLMs from Ollama to run Mem0 locally. These [models](https://ollama.com/search?c=tools) support tool support. + +## Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" # for embedder + +config = { + "llm": { + "provider": "ollama", + "config": { + "model": "mixtral:8x7b", + "temperature": 0.1, + "max_tokens": 2000, + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + llm: { + provider: 'ollama', + config: { + model: 'llama3.1:8b', // or any other Ollama model + url: 'http://localhost:11434', // Ollama server URL + temperature: 0.1, + }, + }, +}; + +const memory = new Memory(config); +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +await memory.add(messages, { userId: "alice", metadata: { category: "movies" } }); +``` + + +## Config + +All available parameters for the `ollama` config are present in [Master List of All Params in Config](../config). \ No newline at end of file diff --git a/docs/v0x/components/llms/models/openai.mdx b/docs/v0x/components/llms/models/openai.mdx new file mode 100644 index 000000000..d31723838 --- /dev/null +++ b/docs/v0x/components/llms/models/openai.mdx @@ -0,0 +1,99 @@ +--- +title: OpenAI +--- + +To use OpenAI LLM models, you have to set the `OPENAI_API_KEY` environment variable. You can obtain the OpenAI API key from the [OpenAI Platform](https://platform.openai.com/account/api-keys). + +> **Note**: The following are currently unsupported with reasoning models `Parallel tool calling`,`temperature`, `top_p`, `presence_penalty`, `frequency_penalty`, `logprobs`, `top_logprobs`, `logit_bias`, `max_tokens` + +## Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" + +config = { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4o", + "temperature": 0.2, + "max_tokens": 2000, + } + } +} + +# Use Openrouter by passing it's api key +# os.environ["OPENROUTER_API_KEY"] = "your-api-key" +# config = { +# "llm": { +# "provider": "openai", +# "config": { +# "model": "meta-llama/llama-3.1-70b-instruct", +# } +# } +# } + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + llm: { + provider: 'openai', + config: { + apiKey: process.env.OPENAI_API_KEY || '', + model: 'gpt-4-turbo-preview', + temperature: 0.2, + maxTokens: 1500, + }, + }, +}; + +const memory = new Memory(config); +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +await memory.add(messages, { userId: "alice", metadata: { category: "movies" } }); +``` + + +We also support the new [OpenAI structured-outputs](https://platform.openai.com/docs/guides/structured-outputs/introduction) model. + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" + +config = { + "llm": { + "provider": "openai_structured", + "config": { + "model": "gpt-4o-2024-08-06", + "temperature": 0.0, + } + } +} + +m = Memory.from_config(config) +``` + +## Config + +All available parameters for the `openai` config are present in [Master List of All Params in Config](../config). diff --git a/docs/v0x/components/llms/models/sarvam.mdx b/docs/v0x/components/llms/models/sarvam.mdx new file mode 100644 index 000000000..0bf1e52df --- /dev/null +++ b/docs/v0x/components/llms/models/sarvam.mdx @@ -0,0 +1,73 @@ +--- +title: Sarvam AI +--- + +**Sarvam AI** is an Indian AI company developing language models with a focus on Indian languages and cultural context. Their latest model **Sarvam-M** is designed to understand and generate content in multiple Indian languages while maintaining high performance in English. + +To use Sarvam AI's models, please set the `SARVAM_API_KEY` which you can get from their [platform](https://dashboard.sarvam.ai/). + +## Usage + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model +os.environ["SARVAM_API_KEY"] = "your-api-key" + +config = { + "llm": { + "provider": "sarvam", + "config": { + "model": "sarvam-m", + "temperature": 0.7, + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alex") +``` + +## Advanced Usage with Sarvam-Specific Features + +```python +import os +from mem0 import Memory + +config = { + "llm": { + "provider": "sarvam", + "config": { + "model": { + "name": "sarvam-m", + "reasoning_effort": "high", # Enable advanced reasoning + "frequency_penalty": 0.1, # Reduce repetition + "seed": 42 # For deterministic outputs + }, + "temperature": 0.3, + "max_tokens": 2000, + "api_key": "your-sarvam-api-key" + } + } +} + +m = Memory.from_config(config) + +# Example with Hindi conversation +messages = [ + {"role": "user", "content": "मैं SBI में joint account खोलना चाहता हूँ।"}, + {"role": "assistant", "content": "SBI में joint account खोलने के लिए आपको कुछ documents की जरूरत होगी। क्या आप जानना चाहते हैं कि कौन से documents चाहिए?"} +] +m.add(messages, user_id="rajesh", metadata={"language": "hindi", "topic": "banking"}) +``` + +## Config + +All available parameters for the `sarvam` config are present in [Master List of All Params in Config](../config). diff --git a/docs/v0x/components/llms/models/together.mdx b/docs/v0x/components/llms/models/together.mdx new file mode 100644 index 000000000..63182918e --- /dev/null +++ b/docs/v0x/components/llms/models/together.mdx @@ -0,0 +1,35 @@ +To use TogetherAI LLM models, you have to set the `TOGETHER_API_KEY` environment variable. You can obtain the TogetherAI API key from their [Account settings page](https://api.together.xyz/settings/api-keys). + +## Usage + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model +os.environ["TOGETHER_API_KEY"] = "your-api-key" + +config = { + "llm": { + "provider": "together", + "config": { + "model": "mistralai/Mixtral-8x7B-Instruct-v0.1", + "temperature": 0.2, + "max_tokens": 2000, + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +## Config + +All available parameters for the `togetherai` config are present in [Master List of All Params in Config](../config). \ No newline at end of file diff --git a/docs/v0x/components/llms/models/vllm.mdx b/docs/v0x/components/llms/models/vllm.mdx new file mode 100644 index 000000000..1b60c1ab9 --- /dev/null +++ b/docs/v0x/components/llms/models/vllm.mdx @@ -0,0 +1,107 @@ +--- +title: vLLM +--- + +[vLLM](https://docs.vllm.ai/) is a high-performance inference engine for large language models that provides significant performance improvements for local inference. It's designed to maximize throughput and memory efficiency for serving LLMs. + +## Prerequisites + +1. **Install vLLM**: + + ```bash + pip install vllm + ``` + +2. **Start vLLM server**: + + ```bash + # For testing with a small model + vllm serve microsoft/DialoGPT-medium --port 8000 + + # For production with a larger model (requires GPU) + vllm serve Qwen/Qwen2.5-32B-Instruct --port 8000 + ``` + +## Usage + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model + +config = { + "llm": { + "provider": "vllm", + "config": { + "model": "Qwen/Qwen2.5-32B-Instruct", + "vllm_base_url": "http://localhost:8000/v1", + "temperature": 0.1, + "max_tokens": 2000, + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thrillers, but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thrillers and suggest sci-fi movies instead."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +## Configuration Parameters + +| Parameter | Description | Default | Environment Variable | +| --------------- | --------------------------------- | ----------------------------- | -------------------- | +| `model` | Model name running on vLLM server | `"Qwen/Qwen2.5-32B-Instruct"` | - | +| `vllm_base_url` | vLLM server URL | `"http://localhost:8000/v1"` | `VLLM_BASE_URL` | +| `api_key` | API key (dummy for local) | `"vllm-api-key"` | `VLLM_API_KEY` | +| `temperature` | Sampling temperature | `0.1` | - | +| `max_tokens` | Maximum tokens to generate | `2000` | - | + +## Environment Variables + +You can set these environment variables instead of specifying them in config: + +```bash +export VLLM_BASE_URL="http://localhost:8000/v1" +export VLLM_API_KEY="your-vllm-api-key" +export OPENAI_API_KEY="your-openai-api-key" # for embeddings +``` + +## Benefits + +- **High Performance**: 2-24x faster inference than standard implementations +- **Memory Efficient**: Optimized memory usage with PagedAttention +- **Local Deployment**: Keep your data private and reduce API costs +- **Easy Integration**: Drop-in replacement for other LLM providers +- **Flexible**: Works with any model supported by vLLM + +## Troubleshooting + +1. **Server not responding**: Make sure vLLM server is running + + ```bash + curl http://localhost:8000/health + ``` + +2. **404 errors**: Ensure correct base URL format + + ```python + "vllm_base_url": "http://localhost:8000/v1" # Note the /v1 + ``` + +3. **Model not found**: Check model name matches server + +4. **Out of memory**: Try smaller models or reduce `max_model_len` + + ```bash + vllm serve Qwen/Qwen2.5-32B-Instruct --max-model-len 4096 + ``` + +## Config + +All available parameters for the `vllm` config are present in [Master List of All Params in Config](../config). diff --git a/docs/v0x/components/llms/models/xAI.mdx b/docs/v0x/components/llms/models/xAI.mdx new file mode 100644 index 000000000..39b159ca4 --- /dev/null +++ b/docs/v0x/components/llms/models/xAI.mdx @@ -0,0 +1,41 @@ +--- +title: xAI +--- + +[xAI](https://x.ai/) is a new AI company founded by Elon Musk that develops large language models, including Grok. Grok is trained on real-time data from X (formerly Twitter) and aims to provide accurate, up-to-date responses with a touch of wit and humor. + +In order to use LLMs from xAI, go to their [platform](https://console.x.ai) and get the API key. Set the API key as `XAI_API_KEY` environment variable to use the model as given below in the example. + +## Usage + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model +os.environ["XAI_API_KEY"] = "your-api-key" + +config = { + "llm": { + "provider": "xai", + "config": { + "model": "grok-3-beta", + "temperature": 0.1, + "max_tokens": 2000, + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +## Config + +All available parameters for the `xai` config are present in [Master List of All Params in Config](../config). \ No newline at end of file diff --git a/docs/v0x/components/llms/overview.mdx b/docs/v0x/components/llms/overview.mdx new file mode 100644 index 000000000..68ae2e4bd --- /dev/null +++ b/docs/v0x/components/llms/overview.mdx @@ -0,0 +1,63 @@ +--- +title: Overview +icon: "info" +iconType: "solid" +--- + +Mem0 includes built-in support for various popular large language models. Memory can utilize the LLM provided by the user, ensuring efficient use for specific needs. + +## Usage + +To use a llm, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `OpenAI` will be used as the llm. + +For a comprehensive list of available parameters for llm configuration, please refer to [Config](./config). + +## Supported LLMs + +See the list of supported LLMs below. + + + All LLMs are supported in Python. The following LLMs are also supported in TypeScript: **OpenAI**, **Anthropic**, and **Groq**. + + + + + + + + + + + + + + + + + + + + +## Structured vs Unstructured Outputs + +Mem0 supports two types of OpenAI LLM formats, each with its own strengths and use cases: + +### Structured Outputs + +Structured outputs are LLMs that align with OpenAI's structured outputs model: + +- **Optimized for:** Returning structured responses (e.g., JSON objects) +- **Benefits:** Precise, easily parseable data +- **Ideal for:** Data extraction, form filling, API responses +- **Learn more:** [OpenAI Structured Outputs Guide](https://platform.openai.com/docs/guides/structured-outputs/introduction) + +### Unstructured Outputs + +Unstructured outputs correspond to OpenAI's standard, free-form text model: + +- **Flexibility:** Returns open-ended, natural language responses +- **Customization:** Use the `response_format` parameter to guide output +- **Trade-off:** Less efficient than structured outputs for specific data needs +- **Best for:** Creative writing, explanations, general conversation + +Choose the format that best suits your application's requirements for optimal performance and usability. diff --git a/docs/v0x/components/vectordbs/config.mdx b/docs/v0x/components/vectordbs/config.mdx new file mode 100644 index 000000000..89d995d21 --- /dev/null +++ b/docs/v0x/components/vectordbs/config.mdx @@ -0,0 +1,128 @@ +--- +title: Configurations +icon: "gear" +iconType: "solid" +--- + +## How to define configurations? + +The `config` is defined as an object with two main keys: +- `vector_store`: Specifies the vector database provider and its configuration + - `provider`: The name of the vector database (e.g., "chroma", "pgvector", "qdrant", "milvus", "upstash_vector", "azure_ai_search", "vertex_ai_vector_search", "valkey") + - `config`: A nested dictionary containing provider-specific settings + + +## How to Use Config + +Here's a general example of how to use the config with mem0: + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "sk-xx" + +config = { + "vector_store": { + "provider": "your_chosen_provider", + "config": { + # Provider-specific settings go here + } + } +} + +m = Memory.from_config(config) +m.add("Your text here", user_id="user", metadata={"category": "example"}) +``` + +```typescript TypeScript +// Example for in-memory vector database (Only supported in TypeScript) +import { Memory } from 'mem0ai/oss'; + +const configMemory = { + vector_store: { + provider: 'memory', + config: { + collectionName: 'memories', + dimension: 1536, + }, + }, +}; + +const memory = new Memory(configMemory); +await memory.add("Your text here", { userId: "user", metadata: { category: "example" } }); +``` + + + + The in-memory vector database is only supported in the TypeScript implementation. + + +## Why is Config Needed? + +Config is essential for: +1. Specifying which vector database to use. +2. Providing necessary connection details (e.g., host, port, credentials). +3. Customizing database-specific settings (e.g., collection name, path). +4. Ensuring proper initialization and connection to your chosen vector store. + +## Master List of All Params in Config + +Here's a comprehensive list of all parameters that can be used across different vector databases: + + + +| Parameter | Description | +|-----------|-------------| +| `collection_name` | Name of the collection | +| `embedding_model_dims` | Dimensions of the embedding model | +| `client` | Custom client for the database | +| `path` | Path for the database | +| `host` | Host where the server is running | +| `port` | Port where the server is running | +| `user` | Username for database connection | +| `password` | Password for database connection | +| `dbname` | Name of the database | +| `url` | Full URL for the server | +| `api_key` | API key for the server | +| `on_disk` | Enable persistent storage | +| `endpoint_id` | Endpoint ID (vertex_ai_vector_search) | +| `index_id` | Index ID (vertex_ai_vector_search) | +| `deployment_index_id` | Deployment index ID (vertex_ai_vector_search) | +| `project_id` | Project ID (vertex_ai_vector_search) | +| `project_number` | Project number (vertex_ai_vector_search) | +| `vector_search_api_endpoint` | Vector search API endpoint (vertex_ai_vector_search) | +| `connection_string` | PostgreSQL connection string (for Supabase/PGVector) | +| `index_method` | Vector index method (for Supabase) | +| `index_measure` | Distance measure for similarity search (for Supabase) | + + +| Parameter | Description | +|-----------|-------------| +| `collectionName` | Name of the collection | +| `embeddingModelDims` | Dimensions of the embedding model | +| `dimension` | Dimensions of the embedding model (for memory provider) | +| `host` | Host where the server is running | +| `port` | Port where the server is running | +| `url` | URL for the server | +| `apiKey` | API key for the server | +| `path` | Path for the database | +| `onDisk` | Enable persistent storage | +| `redisUrl` | URL for the Redis server | +| `username` | Username for database connection | +| `password` | Password for database connection | + + + +## Customizing Config + +Each vector database has its own specific configuration requirements. To customize the config for your chosen vector store: + +1. Identify the vector database you want to use from [supported vector databases](./dbs). +2. Refer to the `Config` section in the respective vector database's documentation. +3. Include only the relevant parameters for your chosen database in the `config` dictionary. + +## Supported Vector Databases + +For detailed information on configuring specific vector databases, please visit the [Supported Vector Databases](./dbs) section. There you'll find individual pages for each supported vector store with provider-specific usage examples and configuration details. diff --git a/docs/v0x/components/vectordbs/dbs/azure.mdx b/docs/v0x/components/vectordbs/dbs/azure.mdx new file mode 100644 index 000000000..824b8e056 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/azure.mdx @@ -0,0 +1,179 @@ +--- +title: Azure AI Search +--- + +[Azure AI Search](https://learn.microsoft.com/azure/search/search-what-is-azure-search/) (formerly known as "Azure Cognitive Search") provides secure information retrieval at scale over user-owned content in traditional and generative AI search applications. + +## Usage + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "sk-xx" # This key is used for embedding purpose + +config = { + "vector_store": { + "provider": "azure_ai_search", + "config": { + "service_name": "", + "api_key": "", + "collection_name": "mem0", + "embedding_model_dims": 1536 + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +## Using binary compression for large vector collections + +```python +config = { + "vector_store": { + "provider": "azure_ai_search", + "config": { + "service_name": "", + "api_key": "", + "collection_name": "mem0", + "embedding_model_dims": 1536, + "compression_type": "binary", + "use_float16": True # Use half precision for storage efficiency + } + } +} +``` + +## Using hybrid search + +```python +config = { + "vector_store": { + "provider": "azure_ai_search", + "config": { + "service_name": "", + "api_key": "", + "collection_name": "mem0", + "embedding_model_dims": 1536, + "hybrid_search": True, + "vector_filter_mode": "postFilter" + } + } +} +``` + +## Using Azure Identity for Authentication +As an alternative to using an API key, the Azure Identity credential chain can be used to authenticate with Azure OpenAI. The list below shows the order of precedence for credential application: + +1. **Environment Credential:** +Azure client ID, secret, tenant ID, or certificate in environment variables for service principal authentication. + +2. **Workload Identity Credential:** +Utilizes Azure Workload Identity (relevant for Kubernetes and Azure workloads). + +3. **Managed Identity Credential:** +Authenticates as a Managed Identity (for apps/services hosted in Azure with Managed Identity enabled), this is the most secure production credential. + +4. **Shared Token Cache Credential / Visual Studio Credential (Windows only):** +Uses cached credentials from Visual Studio sign-ins (and sometimes VS Code if SSO is enabled). + +5. **Azure CLI Credential:** +Uses the currently logged-in user from the Azure CLI (`az login`), this is the most common development credential. + +6. **Azure PowerShell Credential:** +Uses the identity from Azure PowerShell (`Connect-AzAccount`). + +7. **Azure Developer CLI Credential:** +Uses the session from Azure Developer CLI (`azd auth login`). + + If an API is provided, it will be used for authentication over an Azure Identity +To enable Role-Based Access Control (RBAC) for Azure AI Search, follow these steps: + +1. In the Azure Portal, navigate to your **Azure AI Search** service. +2. In the left menu, select **Settings** > **Keys**. +3. Change the authentication setting to **Role-based access control**, or **Both** if you need API key compatibility. The default is “Key-based authentication”—you must switch it to use Azure roles. +4. **Go to Access Control (IAM):** + - In the Azure Portal, select your Search service. + - Click **Access Control (IAM)** on the left. +5. **Add a Role Assignment:** + - Click **Add** > **Add role assignment**. +6. **Choose Role:** + - Mem0 requires the **Search Index Data Contributor** and **Search Service Contributor** role. +7. **Choose Member** + - To assign to a User, Group, Service Principle or Managed Identity: + - For production it is recommended to use a service principal or managed identity. + - For a service principal: select **User, group, or service principal** and search for the service principal. + - For a managed identity: select **Managed identity** and choose the managed identity. + - For development, you can assign the role to a user account. + - For development: select ***User, group, or service principal** and pick a Azure Entra ID account (the same used with `az login`). +8. **Complete the Assignment:** + - Click **Review + Assign**. + +If you are using Azure Identity, do not set the `api_key` in the configuration. +```python +config = { + "vector_store": { + "provider": "azure_ai_search", + "config": { + "service_name": "", + "collection_name": "mem0", + "embedding_model_dims": 1536, + "compression_type": "binary", + "use_float16": True # Use half precision for storage efficiency + } + } +} +``` + +### Environment Variables to set to use Azure Identity Credential: +* For an Environment Credential, you will need to setup a Service Principal and set the following environment variables: + - `AZURE_TENANT_ID`: Your Azure Active Directory tenant ID. + - `AZURE_CLIENT_ID`: The client ID of your service principal or managed identity. + - `AZURE_CLIENT_SECRET`: The client secret of your service principal. +* For a User-Assigned Managed Identity, you will need to set the following environment variable: + - `AZURE_CLIENT_ID`: The client ID of the user-assigned managed identity. +* For a System-Assigned Managed Identity, no additional environment variables are needed. + +### Developer logins to use for a Azure Identity Credential: +* For an Azure CLI Credential, you need to have the Azure CLI installed and logged in with `az login`. +* For an Azure PowerShell Credential, you need to have the Azure PowerShell module installed and logged in with `Connect-AzAccount`. +* For an Azure Developer CLI Credential, you need to have the Azure Developer CLI installed and logged in with `azd auth login`. + +Troubleshooting tips for [Azure Identity](https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/identity/azure-identity/TROUBLESHOOTING.md#troubleshoot-environmentcredential-authentication-issues). + + +## Configuration Parameters + +| Parameter | Description | Default Value | Options | +| --- | --- | --- | --- | +| `service_name` | Azure AI Search service name | Required | - | +| `api_key` | API key of the Azure AI Search service | Optional | If not present, the [Azure Identity](#using-azure-identity-for-authentication) credential chain will be used | +| `collection_name` | The name of the collection/index to store vectors | `mem0` | Any valid index name | +| `embedding_model_dims` | Dimensions of the embedding model | `1536` | Any integer value | +| `compression_type` | Type of vector compression to use | `none` | `none`, `scalar`, `binary` | +| `use_float16` | Store vectors in half precision (Edm.Half) | `False` | `True`, `False` | +| `vector_filter_mode` | Vector filter mode to use | `preFilter` | `postFilter`, `preFilter` | +| `hybrid_search` | Use hybrid search | `False` | `True`, `False` | + +## Notes on Configuration Options + +- **compression_type**: + - `none`: No compression, uses full vector precision + - `scalar`: Scalar quantization with reasonable balance of speed and accuracy + - `binary`: Binary quantization for maximum compression with some accuracy trade-off + +- **vector_filter_mode**: + - `preFilter`: Applies filters before vector search (faster) + - `postFilter`: Applies filters after vector search (may provide better relevance) + +- **use_float16**: Using half precision (float16) reduces storage requirements but may slightly impact accuracy. Useful for very large vector collections. + +- **Filterable Fields**: The implementation automatically extracts `user_id`, `run_id`, and `agent_id` fields from payloads for filtering. \ No newline at end of file diff --git a/docs/v0x/components/vectordbs/dbs/baidu.mdx b/docs/v0x/components/vectordbs/dbs/baidu.mdx new file mode 100644 index 000000000..457fff2ba --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/baidu.mdx @@ -0,0 +1,67 @@ +--- +title: Baidu VectorDB (Mochow) +--- + +[Baidu VectorDB](https://cloud.baidu.com/doc/VDB/index.html) is an enterprise-level distributed vector database service developed by Baidu Intelligent Cloud. It is powered by Baidu's proprietary "Mochow" vector database kernel, providing high performance, availability, and security for vector search. + +### Usage + +```python +import os +from mem0 import Memory + +config = { + "vector_store": { + "provider": "baidu", + "config": { + "endpoint": "http://your-mochow-endpoint:8287", + "account": "root", + "api_key": "your-api-key", + "database_name": "mem0", + "table_name": "mem0_table", + "embedding_model_dims": 1536, + "metric_type": "COSINE" + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movie? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +### Config + +Here are the available parameters for the `mochow` config: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `endpoint` | Endpoint URL for your Baidu VectorDB instance | Required | +| `account` | Baidu VectorDB account name | `root` | +| `api_key` | API key for accessing Baidu VectorDB | Required | +| `database_name` | Name of the database | `mem0` | +| `table_name` | Name of the table | `mem0_table` | +| `embedding_model_dims` | Dimensions of the embedding model | `1536` | +| `metric_type` | Distance metric for similarity search | `L2` | + +### Distance Metrics + +The following distance metrics are supported: + +- `L2`: Euclidean distance (default) +- `IP`: Inner product +- `COSINE`: Cosine similarity + +### Index Configuration + +The vector index is automatically configured with the following HNSW parameters: + +- `m`: 16 (number of connections per element) +- `efconstruction`: 200 (size of the dynamic candidate list) +- `auto_build`: true (automatically build index) +- `auto_build_index_policy`: Incremental build with 10000 rows increment diff --git a/docs/v0x/components/vectordbs/dbs/chroma.mdx b/docs/v0x/components/vectordbs/dbs/chroma.mdx new file mode 100644 index 000000000..2e546b883 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/chroma.mdx @@ -0,0 +1,48 @@ +[Chroma](https://www.trychroma.com/) is an AI-native open-source vector database that simplifies building LLM apps by providing tools for storing, embedding, and searching embeddings with a focus on simplicity and speed. It supports both local deployment and cloud hosting through ChromaDB Cloud. + +### Usage + +#### Local Installation + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "sk-xx" + +config = { + "vector_store": { + "provider": "chroma", + "config": { + "collection_name": "test", + "path": "db", + # Optional: ChromaDB Cloud configuration + # "api_key": "your-chroma-cloud-api-key", + # "tenant": "your-chroma-cloud-tenant-id", + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +### Config + +Here are the parameters available for configuring Chroma: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `collection_name` | The name of the collection | `mem0` | +| `client` | Custom client for Chroma | `None` | +| `path` | Path for the Chroma database | `db` | +| `host` | The host where the Chroma server is running | `None` | +| `port` | The port where the Chroma server is running | `None` | +| `api_key` | ChromaDB Cloud API key (for cloud usage) | `None` | +| `tenant` | ChromaDB Cloud tenant ID (for cloud usage) | `None` | \ No newline at end of file diff --git a/docs/v0x/components/vectordbs/dbs/databricks.mdx b/docs/v0x/components/vectordbs/dbs/databricks.mdx new file mode 100644 index 000000000..add8ee517 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/databricks.mdx @@ -0,0 +1,130 @@ +[Databricks Vector Search](https://docs.databricks.com/en/generative-ai/vector-search.html) is a serverless similarity search engine that allows you to store a vector representation of your data, including metadata, in a vector database. With Vector Search, you can create auto-updating vector search indexes from Delta tables managed by Unity Catalog and query them with a simple API to return the most similar vectors. + +### Usage + +```python +import os +from mem0 import Memory + +config = { + "vector_store": { + "provider": "databricks", + "config": { + "workspace_url": "https://your-workspace.databricks.com", + "access_token": "your-access-token", + "endpoint_name": "your-vector-search-endpoint", + "index_name": "catalog.schema.index_name", + "source_table_name": "catalog.schema.source_table", + "embedding_dimension": 1536 + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +### Config + +Here are the parameters available for configuring Databricks Vector Search: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `workspace_url` | The URL of your Databricks workspace | **Required** | +| `access_token` | Personal Access Token for authentication | `None` | +| `service_principal_client_id` | Service principal client ID (alternative to access_token) | `None` | +| `service_principal_client_secret` | Service principal client secret (required with client_id) | `None` | +| `endpoint_name` | Name of the Vector Search endpoint | **Required** | +| `index_name` | Name of the vector index (Unity Catalog format: catalog.schema.index) | **Required** | +| `source_table_name` | Name of the source Delta table (Unity Catalog format: catalog.schema.table) | **Required** | +| `embedding_dimension` | Dimension of self-managed embeddings | `1536` | +| `embedding_source_column` | Column name for text when using Databricks-computed embeddings | `None` | +| `embedding_model_endpoint_name` | Databricks serving endpoint for embeddings | `None` | +| `embedding_vector_column` | Column name for self-managed embedding vectors | `embedding` | +| `endpoint_type` | Type of endpoint (`STANDARD` or `STORAGE_OPTIMIZED`) | `STANDARD` | +| `sync_computed_embeddings` | Whether to sync computed embeddings automatically | `True` | + +### Authentication + +Databricks Vector Search supports two authentication methods: + +#### Service Principal (Recommended for Production) +```python +config = { + "vector_store": { + "provider": "databricks", + "config": { + "workspace_url": "https://your-workspace.databricks.com", + "service_principal_client_id": "your-service-principal-id", + "service_principal_client_secret": "your-service-principal-secret", + "endpoint_name": "your-endpoint", + "index_name": "catalog.schema.index_name", + "source_table_name": "catalog.schema.source_table" + } + } +} +``` + +#### Personal Access Token (for Development) +```python +config = { + "vector_store": { + "provider": "databricks", + "config": { + "workspace_url": "https://your-workspace.databricks.com", + "access_token": "your-personal-access-token", + "endpoint_name": "your-endpoint", + "index_name": "catalog.schema.index_name", + "source_table_name": "catalog.schema.source_table" + } + } +} +``` + +### Embedding Options + +#### Self-Managed Embeddings (Default) +Use your own embedding model and provide vectors directly: + +```python +config = { + "vector_store": { + "provider": "databricks", + "config": { + # ... authentication config ... + "embedding_dimension": 768, # Match your embedding model + "embedding_vector_column": "embedding" + } + } +} +``` + +#### Databricks-Computed Embeddings +Let Databricks compute embeddings from text using a serving endpoint: + +```python +config = { + "vector_store": { + "provider": "databricks", + "config": { + # ... authentication config ... + "embedding_source_column": "text", + "embedding_model_endpoint_name": "e5-small-v2" + } + } +} +``` + +### Important Notes + +- **Delta Sync Index**: This implementation uses Delta Sync Index, which automatically syncs with your source Delta table. Direct vector insertion/deletion/update operations will log warnings as they're not supported with Delta Sync. +- **Unity Catalog**: Both the source table and index must be in Unity Catalog format (`catalog.schema.table_name`). +- **Endpoint Auto-Creation**: If the specified endpoint doesn't exist, it will be created automatically. +- **Index Auto-Creation**: If the specified index doesn't exist, it will be created automatically with the provided configuration. +- **Filter Support**: Supports filtering by metadata fields, with different syntax for STANDARD vs STORAGE_OPTIMIZED endpoints. diff --git a/docs/v0x/components/vectordbs/dbs/elasticsearch.mdx b/docs/v0x/components/vectordbs/dbs/elasticsearch.mdx new file mode 100644 index 000000000..5e735d232 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/elasticsearch.mdx @@ -0,0 +1,109 @@ +[Elasticsearch](https://www.elastic.co/) is a distributed, RESTful search and analytics engine that can efficiently store and search vector data using dense vectors and k-NN search. + +### Installation + +Elasticsearch support requires additional dependencies. Install them with: + +```bash +pip install elasticsearch>=8.0.0 +``` + +### Usage + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "sk-xx" + +config = { + "vector_store": { + "provider": "elasticsearch", + "config": { + "collection_name": "mem0", + "host": "localhost", + "port": 9200, + "embedding_model_dims": 1536 + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +### Config + +Let's see the available parameters for the `elasticsearch` config: + +| Parameter | Description | Default Value | +| ---------------------- | -------------------------------------------------- | ------------- | +| `collection_name` | The name of the index to store the vectors | `mem0` | +| `embedding_model_dims` | Dimensions of the embedding model | `1536` | +| `host` | The host where the Elasticsearch server is running | `localhost` | +| `port` | The port where the Elasticsearch server is running | `9200` | +| `cloud_id` | Cloud ID for Elastic Cloud deployment | `None` | +| `api_key` | API key for authentication | `None` | +| `user` | Username for basic authentication | `None` | +| `password` | Password for basic authentication | `None` | +| `verify_certs` | Whether to verify SSL certificates | `True` | +| `auto_create_index` | Whether to automatically create the index | `True` | +| `custom_search_query` | Function returning a custom search query | `None` | +| `headers` | Custom headers to include in requests | `None` | + +### Features + +- Efficient vector search using Elasticsearch's native k-NN search +- Support for both local and cloud deployments (Elastic Cloud) +- Multiple authentication methods (Basic Auth, API Key) +- Automatic index creation with optimized mappings for vector search +- Memory isolation through payload filtering +- Custom search query function to customize the search query + +### Custom Search Query + +The `custom_search_query` parameter allows you to customize the search query when `Memory.search` is called. + +__Example__ +```python +import os +from typing import List, Optional, Dict +from mem0 import Memory + +def custom_search_query(query: List[float], limit: int, filters: Optional[Dict]) -> Dict: + return { + "knn": { + "field": "vector", + "query_vector": query, + "k": limit, + "num_candidates": limit * 2 + } + } + +os.environ["OPENAI_API_KEY"] = "sk-xx" + +config = { + "vector_store": { + "provider": "elasticsearch", + "config": { + "collection_name": "mem0", + "host": "localhost", + "port": 9200, + "embedding_model_dims": 1536, + "custom_search_query": custom_search_query + } + } +} +``` +It should be a function that takes the following parameters: +- `query`: a query vector used in `Memory.search` +- `limit`: a number of results used in `Memory.search` +- `filters`: a dictionary of key-value pairs used in `Memory.search`. You can add custom pairs for the custom search query. + +The function should return a query body for the Elasticsearch search API. \ No newline at end of file diff --git a/docs/v0x/components/vectordbs/dbs/faiss.mdx b/docs/v0x/components/vectordbs/dbs/faiss.mdx new file mode 100644 index 000000000..19daddabf --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/faiss.mdx @@ -0,0 +1,72 @@ +[FAISS](https://github.com/facebookresearch/faiss) is a library for efficient similarity search and clustering of dense vectors. It is designed to work with large-scale datasets and provides a high-performance search engine for vector data. FAISS is optimized for memory usage and search speed, making it an excellent choice for production environments. + +### Usage + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "sk-xx" + +config = { + "vector_store": { + "provider": "faiss", + "config": { + "collection_name": "test", + "path": "/tmp/faiss_memories", + "distance_strategy": "euclidean" + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +### Installation + +To use FAISS in your mem0 project, you need to install the appropriate FAISS package for your environment: + +```bash +# For CPU version +pip install faiss-cpu + +# For GPU version (requires CUDA) +pip install faiss-gpu +``` + +### Config + +Here are the parameters available for configuring FAISS: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `collection_name` | The name of the collection | `mem0` | +| `path` | Path to store FAISS index and metadata | `/tmp/faiss/` | +| `distance_strategy` | Distance metric strategy to use (options: 'euclidean', 'inner_product', 'cosine') | `euclidean` | +| `normalize_L2` | Whether to normalize L2 vectors (only applicable for euclidean distance) | `False` | + +### Performance Considerations + +FAISS offers several advantages for vector search: + +1. **Efficiency**: FAISS is optimized for memory usage and speed, making it suitable for large-scale applications. +2. **Offline Support**: FAISS works entirely locally, with no need for external servers or API calls. +3. **Storage Options**: Vectors can be stored in-memory for maximum speed or persisted to disk. +4. **Multiple Index Types**: FAISS supports different index types optimized for various use cases (though mem0 currently uses the basic flat index). + +### Distance Strategies + +FAISS in mem0 supports three distance strategies: + +- **euclidean**: L2 distance, suitable for most embedding models +- **inner_product**: Dot product similarity, useful for some specialized embeddings +- **cosine**: Cosine similarity, best for comparing semantic similarity regardless of vector magnitude + +When using `cosine` or `inner_product` with normalized vectors, you may want to set `normalize_L2=True` for better results. diff --git a/docs/v0x/components/vectordbs/dbs/langchain.mdx b/docs/v0x/components/vectordbs/dbs/langchain.mdx new file mode 100644 index 000000000..d87ff583a --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/langchain.mdx @@ -0,0 +1,112 @@ +--- +title: LangChain +--- + +Mem0 supports LangChain as a provider for vector store integration. LangChain provides a unified interface to various vector databases, making it easy to integrate different vector store providers through a consistent API. + + + When using LangChain as your vector store provider, you must set the collection name to "mem0". This is a required configuration for proper integration with Mem0. + + +## Usage + + +```python Python +import os +from mem0 import Memory +from langchain_community.vectorstores import Chroma +from langchain_openai import OpenAIEmbeddings + +# Initialize a LangChain vector store +embeddings = OpenAIEmbeddings() +vector_store = Chroma( + persist_directory="./chroma_db", + embedding_function=embeddings, + collection_name="mem0" # Required collection name +) + +# Pass the initialized vector store to the config +config = { + "vector_store": { + "provider": "langchain", + "config": { + "client": vector_store + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +```typescript TypeScript +import { Memory } from "mem0ai"; +import { OpenAIEmbeddings } from "@langchain/openai"; +import { MemoryVectorStore as LangchainMemoryStore } from "langchain/vectorstores/memory"; + +const embeddings = new OpenAIEmbeddings(); +const vectorStore = new LangchainVectorStore(embeddings); + +const config = { + "vector_store": { + "provider": "langchain", + "config": { "client": vectorStore } + } +} + +const memory = new Memory(config); + +const messages = [ + { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" }, + { role: "assistant", content: "How about a thriller movies? They can be quite engaging." }, + { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." }, + { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." } +] + +memory.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + + +## Supported LangChain Vector Stores + +LangChain supports a wide range of vector store providers, including: + +- Chroma +- FAISS +- Pinecone +- Weaviate +- Milvus +- Qdrant +- And many more + +You can use any of these vector store instances directly in your configuration. For a complete and up-to-date list of available providers, refer to the [LangChain Vector Stores documentation](https://python.langchain.com/docs/integrations/vectorstores). + +## Limitations + +When using LangChain as a vector store provider, there are some limitations to be aware of: + +1. **Bulk Operations**: The `get_all` and `delete_all` operations are not supported when using LangChain as the vector store provider. This is because LangChain's vector store interface doesn't provide standardized methods for these bulk operations across all providers. + +2. **Provider-Specific Features**: Some advanced features may not be available depending on the specific vector store implementation you're using through LangChain. + +## Provider-Specific Configuration + +When using LangChain as a vector store provider, you'll need to: + +1. Set the appropriate environment variables for your chosen vector store provider +2. Import and initialize the specific vector store class you want to use +3. Pass the initialized vector store instance to the config + + + Make sure to install the necessary LangChain packages and any provider-specific dependencies. + + +## Config + +All available parameters for the `langchain` vector store config are present in [Master List of All Params in Config](../config). diff --git a/docs/v0x/components/vectordbs/dbs/milvus.mdx b/docs/v0x/components/vectordbs/dbs/milvus.mdx new file mode 100644 index 000000000..0e33f2766 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/milvus.mdx @@ -0,0 +1,43 @@ +[Milvus](https://milvus.io/) Milvus is an open-source vector database that suits AI applications of every size from running a demo chatbot in Jupyter notebook to building web-scale search that serves billions of users. + +### Usage + +```python +import os +from mem0 import Memory + +config = { + "vector_store": { + "provider": "milvus", + "config": { + "collection_name": "test", + "embedding_model_dims": "123", + "url": "127.0.0.1", + "token": "8e4b8ca8cf2c67", + "db_name": "my_database", + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +### Config + +Here's the parameters available for configuring Milvus Database: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `url` | Full URL/Uri for Milvus/Zilliz server | `http://localhost:19530` | +| `token` | Token for Zilliz server / for local setup defaults to None. | `None` | +| `collection_name` | The name of the collection | `mem0` | +| `embedding_model_dims` | Dimensions of the embedding model | `1536` | +| `metric_type` | Metric type for similarity search | `L2` | +| `db_name` | Name of the database | `""` | diff --git a/docs/v0x/components/vectordbs/dbs/mongodb.mdx b/docs/v0x/components/vectordbs/dbs/mongodb.mdx new file mode 100644 index 000000000..3fea21c3a --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/mongodb.mdx @@ -0,0 +1,45 @@ +# MongoDB + +[MongoDB](https://www.mongodb.com/) is a versatile document database that supports vector search capabilities, allowing for efficient high-dimensional similarity searches over large datasets with robust scalability and performance. + +## Usage + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "sk-xx" + +config = { + "vector_store": { + "provider": "mongodb", + "config": { + "db_name": "mem0-db", + "collection_name": "mem0-collection", + "mongo_uri":"mongodb://username:password@localhost:27017" + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +## Config + +Here are the parameters available for configuring MongoDB: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| db_name | Name of the MongoDB database | `"mem0_db"` | +| collection_name | Name of the MongoDB collection | `"mem0_collection"` | +| embedding_model_dims | Dimensions of the embedding vectors | `1536` | +| mongo_uri | The mongo URI connection string | mongodb://username:password@localhost:27017 | + +> **Note**: If Mongo_uri is not provided it will default to mongodb://username:password@localhost:27017. diff --git a/docs/v0x/components/vectordbs/dbs/neptune_analytics.mdx b/docs/v0x/components/vectordbs/dbs/neptune_analytics.mdx new file mode 100644 index 000000000..f8396cf44 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/neptune_analytics.mdx @@ -0,0 +1,42 @@ +# Neptune Analytics Vector Store + +[Neptune Analytics](https://docs.aws.amazon.com/neptune-analytics/latest/userguide/what-is-neptune-analytics.html/) is a memory-optimized graph database engine for analytics. With Neptune Analytics, you can get insights and find trends by processing large amounts of graph data in seconds, including vector search. + + +## Installation + +```bash +pip install mem0ai[vector_stores] +``` + +## Usage + +```python +config = { + "vector_store": { + "provider": "neptune", + "config": { + "collection_name": "mem0", + "endpoint": f"neptune-graph://my-graph-identifier", + }, + }, +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +## Parameters + +Let's see the available parameters for the `neptune` config: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `collection_name` | The name of the collection to store the vectors | `mem0` | +| `endpoint` | Connection URL for the Neptune Analytics service | `neptune-graph://my-graph-identifier` | diff --git a/docs/v0x/components/vectordbs/dbs/opensearch.mdx b/docs/v0x/components/vectordbs/dbs/opensearch.mdx new file mode 100644 index 000000000..4c0a72902 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/opensearch.mdx @@ -0,0 +1,81 @@ +[OpenSearch](https://opensearch.org/) is an enterprise-grade search and observability suite that brings order to unstructured data at scale. OpenSearch supports k-NN (k-Nearest Neighbors) and allows you to store and retrieve high-dimensional vector embeddings efficiently. + +### Installation + +OpenSearch support requires additional dependencies. Install them with: + +```bash +pip install opensearch-py +``` + +### Prerequisites + +Before using OpenSearch with Mem0, you need to set up a collection in AWS OpenSearch Service. + +#### AWS OpenSearch Service +You can create a collection through the AWS Console: +- Navigate to [OpenSearch Service Console](https://console.aws.amazon.com/aos/home) +- Click "Create collection" +- Select "Serverless collection" and then enable "Vector search" capabilities +- Once created, note the endpoint URL (host) for your configuration + + +### Usage + +```python +import os +from mem0 import Memory +import boto3 +from opensearchpy import OpenSearch, RequestsHttpConnection, AWSV4SignerAuth + +# For AWS OpenSearch Service with IAM authentication +region = 'us-west-2' +service = 'aoss' +credentials = boto3.Session().get_credentials() +auth = AWSV4SignerAuth(credentials, region, service) + +config = { + "vector_store": { + "provider": "opensearch", + "config": { + "collection_name": "mem0", + "host": "your-domain.us-west-2.aoss.amazonaws.com", + "port": 443, + "http_auth": auth, + "embedding_model_dims": 1024, + "connection_class": RequestsHttpConnection, + "pool_maxsize": 20, + "use_ssl": True, + "verify_certs": True + } + } +} +``` + +### Add Memories + +```python +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +### Search Memories + +```python +results = m.search("What kind of movies does Alice like?", user_id="alice") +``` + +### Features + +- Fast and Efficient Vector Search +- Can be deployed on-premises, in containers, or on cloud platforms like AWS OpenSearch Service. +- Multiple Authentication and Security Methods (Basic Authentication, API Keys, LDAP, SAML, and OpenID Connect) +- Automatic index creation with optimized mappings for vector search +- Memory Optimization through Disk-Based Vector Search and Quantization +- Real-Time Analytics and Observability diff --git a/docs/v0x/components/vectordbs/dbs/pgvector.mdx b/docs/v0x/components/vectordbs/dbs/pgvector.mdx new file mode 100644 index 000000000..03836c2db --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/pgvector.mdx @@ -0,0 +1,87 @@ +[pgvector](https://github.com/pgvector/pgvector) is open-source vector similarity search for Postgres. After connecting with postgres run `CREATE EXTENSION IF NOT EXISTS vector;` to create the vector extension. + +### Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "sk-xx" + +config = { + "vector_store": { + "provider": "pgvector", + "config": { + "user": "test", + "password": "123", + "host": "127.0.0.1", + "port": "5432", + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + vectorStore: { + provider: 'pgvector', + config: { + collectionName: 'memories', + embeddingModelDims: 1536, + user: 'test', + password: '123', + host: '127.0.0.1', + port: 5432, + dbname: 'vector_store', // Optional, defaults to 'postgres' + diskann: false, // Optional, requires pgvectorscale extension + hnsw: false, // Optional, for HNSW indexing + }, + }, +}; + +const memory = new Memory(config); +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +await memory.add(messages, { userId: "alice", metadata: { category: "movies" } }); +``` + + +### Config + +Here's the parameters available for configuring pgvector: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `dbname` | The name of the database | `postgres` | +| `collection_name` | The name of the collection | `mem0` | +| `embedding_model_dims` | Dimensions of the embedding model | `1536` | +| `user` | User name to connect to the database | `None` | +| `password` | Password to connect to the database | `None` | +| `host` | The host where the Postgres server is running | `None` | +| `port` | The port where the Postgres server is running | `None` | +| `diskann` | Whether to use diskann for vector similarity search (requires pgvectorscale) | `True` | +| `hnsw` | Whether to use hnsw for vector similarity search | `False` | +| `sslmode` | SSL mode for PostgreSQL connection (e.g., 'require', 'prefer', 'disable') | `None` | +| `connection_string` | PostgreSQL connection string (overrides individual connection parameters) | `None` | +| `connection_pool` | psycopg2 connection pool object (overrides connection string and individual parameters) | `None` | + +**Note**: The connection parameters have the following priority: +1. `connection_pool` (highest priority) +2. `connection_string` +3. Individual connection parameters (`user`, `password`, `host`, `port`, `sslmode`) \ No newline at end of file diff --git a/docs/v0x/components/vectordbs/dbs/pinecone.mdx b/docs/v0x/components/vectordbs/dbs/pinecone.mdx new file mode 100644 index 000000000..8633ab256 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/pinecone.mdx @@ -0,0 +1,98 @@ +[Pinecone](https://www.pinecone.io/) is a fully managed vector database designed for machine learning applications, offering high performance vector search with low latency at scale. It's particularly well-suited for semantic search, recommendation systems, and other AI-powered applications. + +> **New**: Pinecone integration now supports custom namespaces! Use the `namespace` parameter to logically separate data within the same index. This is especially useful for multi-tenant or multi-user applications. + +> **Note**: Before configuring Pinecone, you need to select an embedding model (e.g., OpenAI, Cohere, or custom models) and ensure the `embedding_model_dims` in your config matches your chosen model's dimensions. For example, OpenAI's text-embedding-3-small uses 1536 dimensions. + +### Usage + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "sk-xx" +os.environ["PINECONE_API_KEY"] = "your-api-key" + +# Example using serverless configuration +config = { + "vector_store": { + "provider": "pinecone", + "config": { + "collection_name": "testing", + "embedding_model_dims": 1536, # Matches OpenAI's text-embedding-3-small + "namespace": "my-namespace", # Optional: specify a namespace for multi-tenancy + "serverless_config": { + "cloud": "aws", # Choose between 'aws' or 'gcp' or 'azure' + "region": "us-east-1" + }, + "metric": "cosine" + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +### Config + +Here are the parameters available for configuring Pinecone: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `collection_name` | Name of the index/collection | Required | +| `embedding_model_dims` | Dimensions of the embedding model (must match your chosen embedding model) | Required | +| `client` | Existing Pinecone client instance | `None` | +| `api_key` | API key for Pinecone | Environment variable: `PINECONE_API_KEY` | +| `environment` | Pinecone environment | `None` | +| `serverless_config` | Configuration for serverless deployment (AWS or GCP or Azure) | `None` | +| `pod_config` | Configuration for pod-based deployment | `None` | +| `hybrid_search` | Whether to enable hybrid search | `False` | +| `metric` | Distance metric for vector similarity | `"cosine"` | +| `batch_size` | Batch size for operations | `100` | +| `namespace` | Namespace for the collection, useful for multi-tenancy. | `None` | + +> **Important**: You must choose either `serverless_config` or `pod_config` for your deployment, but not both. + +#### Serverless Config Example +```python +config = { + "vector_store": { + "provider": "pinecone", + "config": { + "collection_name": "memory_index", + "embedding_model_dims": 1536, # For OpenAI's text-embedding-3-small + "namespace": "my-namespace", # Optional: custom namespace + "serverless_config": { + "cloud": "aws", # or "gcp" or "azure" + "region": "us-east-1" # Choose appropriate region + } + } + } +} +``` + +#### Pod Config Example +```python +config = { + "vector_store": { + "provider": "pinecone", + "config": { + "collection_name": "memory_index", + "embedding_model_dims": 1536, # For OpenAI's text-embedding-ada-002 + "namespace": "my-namespace", # Optional: custom namespace + "pod_config": { + "environment": "gcp-starter", + "replicas": 1, + "pod_type": "starter" + } + } + } +} +``` \ No newline at end of file diff --git a/docs/v0x/components/vectordbs/dbs/qdrant.mdx b/docs/v0x/components/vectordbs/dbs/qdrant.mdx new file mode 100644 index 000000000..1fe21c678 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/qdrant.mdx @@ -0,0 +1,89 @@ +[Qdrant](https://qdrant.tech/) is an open-source vector search engine. It is designed to work with large-scale datasets and provides a high-performance search engine for vector data. + +### Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "sk-xx" + +config = { + "vector_store": { + "provider": "qdrant", + "config": { + "collection_name": "test", + "host": "localhost", + "port": 6333, + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + vectorStore: { + provider: 'qdrant', + config: { + collectionName: 'memories', + embeddingModelDims: 1536, + host: 'localhost', + port: 6333, + }, + }, +}; + +const memory = new Memory(config); +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +await memory.add(messages, { userId: "alice", metadata: { category: "movies" } }); +``` + + +### Config + +Let's see the available parameters for the `qdrant` config: + + + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `collection_name` | The name of the collection to store the vectors | `mem0` | +| `embedding_model_dims` | Dimensions of the embedding model | `1536` | +| `client` | Custom client for qdrant | `None` | +| `host` | The host where the qdrant server is running | `None` | +| `port` | The port where the qdrant server is running | `None` | +| `path` | Path for the qdrant database | `/tmp/qdrant` | +| `url` | Full URL for the qdrant server | `None` | +| `api_key` | API key for the qdrant server | `None` | +| `on_disk` | For enabling persistent storage | `False` | + + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `collectionName` | The name of the collection to store the vectors | `mem0` | +| `embeddingModelDims` | Dimensions of the embedding model | `1536` | +| `host` | The host where the Qdrant server is running | `None` | +| `port` | The port where the Qdrant server is running | `None` | +| `path` | Path for the Qdrant database | `/tmp/qdrant` | +| `url` | Full URL for the Qdrant server | `None` | +| `apiKey` | API key for the Qdrant server | `None` | +| `onDisk` | For enabling persistent storage | `False` | + + \ No newline at end of file diff --git a/docs/v0x/components/vectordbs/dbs/redis.mdx b/docs/v0x/components/vectordbs/dbs/redis.mdx new file mode 100644 index 000000000..3e1b7cc96 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/redis.mdx @@ -0,0 +1,92 @@ +[Redis](https://redis.io/) is a scalable, real-time database that can store, search, and analyze vector data. + +### Installation +```bash +pip install redis redisvl +``` + +Redis Stack using Docker: +```bash +docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:latest +``` + +### Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "sk-xx" + +config = { + "vector_store": { + "provider": "redis", + "config": { + "collection_name": "mem0", + "embedding_model_dims": 1536, + "redis_url": "redis://localhost:6379" + } + }, + "version": "v1.1" +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + vectorStore: { + provider: 'redis', + config: { + collectionName: 'memories', + embeddingModelDims: 1536, + redisUrl: 'redis://localhost:6379', + username: 'your-redis-username', + password: 'your-redis-password', + }, + }, +}; + +const memory = new Memory(config); +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +await memory.add(messages, { userId: "alice", metadata: { category: "movies" } }); +``` + + +### Config + +Let's see the available parameters for the `redis` config: + + + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `collection_name` | The name of the collection to store the vectors | `mem0` | +| `embedding_model_dims` | Dimensions of the embedding model | `1536` | +| `redis_url` | The URL of the Redis server | `None` | + + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `collectionName` | The name of the collection to store the vectors | `mem0` | +| `embeddingModelDims` | Dimensions of the embedding model | `1536` | +| `redisUrl` | The URL of the Redis server | `None` | +| `username` | Username for Redis connection | `None` | +| `password` | Password for Redis connection | `None` | + + \ No newline at end of file diff --git a/docs/v0x/components/vectordbs/dbs/s3_vectors.mdx b/docs/v0x/components/vectordbs/dbs/s3_vectors.mdx new file mode 100644 index 000000000..8faf09b46 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/s3_vectors.mdx @@ -0,0 +1,78 @@ +--- +title: Amazon S3 Vectors +--- + +[Amazon S3 Vectors](https://aws.amazon.com/s3/features/vectors/) is a purpose-built, cost-optimized vector storage and query service for semantic search and AI applications. It provides S3-level elasticity and durability with sub-second query performance. + +### Installation + +S3 Vectors support requires additional dependencies. Install them with: + +```bash +pip install boto3 +``` + +### Usage + +To use Amazon S3 Vectors with Mem0, you need to have an AWS account and the necessary IAM permissions (`s3vectors:*`). Ensure your environment is configured with AWS credentials (e.g., via `~/.aws/credentials` or environment variables). + +```python +import os +from mem0 import Memory + +# Ensure your AWS credentials are configured in your environment +# e.g., by setting AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and AWS_DEFAULT_REGION + +config = { + "vector_store": { + "provider": "s3_vectors", + "config": { + "vector_bucket_name": "my-mem0-vector-bucket", + "index_name": "my-memories-index", + "embedding_model_dims": 1536, + "distance_metric": "cosine", + "region_name": "us-east-1" + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movie? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +### Config + +Here are the available parameters for the `s3_vectors` config: + +| Parameter | Description | Default Value | +| ---------------------- | -------------------------------------------------------------------- | ------------- | +| `vector_bucket_name` | The name of the S3 Vector bucket to use. It will be created if it doesn't exist. | Required | +| `index_name` | The name of the vector index within the bucket. | `mem0` | +| `embedding_model_dims` | Dimensions of the embedding model. Must match your embedder. | `1536` | +| `distance_metric` | Distance metric for similarity search. Options: `cosine`, `euclidean`. | `cosine` | +| `region_name` | The AWS region where the bucket and index reside. | `None` (uses default from AWS config) | + +### IAM Permissions + +Your AWS identity (user or role) needs permissions to perform actions on S3 Vectors. A minimal policy would look like this: + +```json +{ + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Action": "s3vectors:*", + "Resource": "*" + } + ] +} +``` + +For production, it is recommended to scope down the resource ARN to your specific buckets and indexes. \ No newline at end of file diff --git a/docs/v0x/components/vectordbs/dbs/supabase.mdx b/docs/v0x/components/vectordbs/dbs/supabase.mdx new file mode 100644 index 000000000..d6dd38727 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/supabase.mdx @@ -0,0 +1,170 @@ +[Supabase](https://supabase.com/) is an open-source Firebase alternative that provides a PostgreSQL database with pgvector extension for vector similarity search. It offers a powerful and scalable solution for storing and querying vector embeddings. + +Create a [Supabase](https://supabase.com/dashboard/projects) account and project, then get your connection string from Project Settings > Database. See the [docs](https://supabase.github.io/vecs/hosting/) for details. + +### Usage + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "sk-xx" + +config = { + "vector_store": { + "provider": "supabase", + "config": { + "connection_string": "postgresql://user:password@host:port/database", + "collection_name": "memories", + "index_method": "hnsw", # Optional: defaults to "auto" + "index_measure": "cosine_distance" # Optional: defaults to "cosine_distance" + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +```typescript Typescript +import { Memory } from "mem0ai/oss"; + +const config = { + vectorStore: { + provider: "supabase", + config: { + collectionName: "memories", + embeddingModelDims: 1536, + supabaseUrl: process.env.SUPABASE_URL || "", + supabaseKey: process.env.SUPABASE_KEY || "", + tableName: "memories", + }, + }, +} + +const memory = new Memory(config); + +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] + +await memory.add(messages, { userId: "alice", metadata: { category: "movies" } }); +``` + + +### SQL Migrations for TypeScript Implementation + +The following SQL migrations are required to enable the vector extension and create the memories table: + +```sql +-- Enable the vector extension +create extension if not exists vector; + +-- Create the memories table +create table if not exists memories ( + id text primary key, + embedding vector(1536), + metadata jsonb, + created_at timestamp with time zone default timezone('utc', now()), + updated_at timestamp with time zone default timezone('utc', now()) +); + +-- Create the vector similarity search function +create or replace function match_vectors( + query_embedding vector(1536), + match_count int, + filter jsonb default '{}'::jsonb +) +returns table ( + id text, + similarity float, + metadata jsonb +) +language plpgsql +as $$ +begin + return query + select + t.id::text, + 1 - (t.embedding <=> query_embedding) as similarity, + t.metadata + from memories t + where case + when filter::text = '{}'::text then true + else t.metadata @> filter + end + order by t.embedding <=> query_embedding + limit match_count; +end; +$$; +``` + +Goto [Supabase](https://supabase.com/dashboard/projects) and run the above SQL migrations inside the SQL Editor. + +### Config + +Here are the parameters available for configuring Supabase: + + + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `connection_string` | PostgreSQL connection string (required) | None | +| `collection_name` | Name for the vector collection | `mem0` | +| `embedding_model_dims` | Dimensions of the embedding model | `1536` | +| `index_method` | Vector index method to use | `auto` | +| `index_measure` | Distance measure for similarity search | `cosine_distance` | + + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `collectionName` | Name for the vector collection | `mem0` | +| `embeddingModelDims` | Dimensions of the embedding model | `1536` | +| `supabaseUrl` | Supabase URL | None | +| `supabaseKey` | Supabase key | None | +| `tableName` | Name for the vector table | `memories` | + + + +### Index Methods + +The following index methods are supported: + +- `auto`: Automatically selects the best available index method +- `hnsw`: Hierarchical Navigable Small World graph index (faster search, more memory usage) +- `ivfflat`: Inverted File Flat index (good balance of speed and memory) + +### Distance Measures + +Available distance measures for similarity search: + +- `cosine_distance`: Cosine similarity (recommended for most embedding models) +- `l2_distance`: Euclidean distance +- `l1_distance`: Manhattan distance +- `max_inner_product`: Maximum inner product similarity + +### Best Practices + +1. **Index Method Selection**: + - Use `hnsw` for fastest search performance when memory is not a constraint + - Use `ivfflat` for a good balance of search speed and memory usage + - Use `auto` if unsure, it will select the best method based on your data + +2. **Distance Measure Selection**: + - Use `cosine_distance` for most embedding models (OpenAI, Hugging Face, etc.) + - Use `max_inner_product` if your vectors are normalized + - Use `l2_distance` or `l1_distance` if working with raw feature vectors + +3. **Connection String**: + - Always use environment variables for sensitive information in the connection string + - Format: `postgresql://user:password@host:port/database` diff --git a/docs/v0x/components/vectordbs/dbs/upstash-vector.mdx b/docs/v0x/components/vectordbs/dbs/upstash-vector.mdx new file mode 100644 index 000000000..c4536d906 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/upstash-vector.mdx @@ -0,0 +1,70 @@ +[Upstash Vector](https://upstash.com/docs/vector) is a serverless vector database with built-in embedding models. + +### Usage with Upstash embeddings + +You can enable the built-in embedding models by setting `enable_embeddings` to `True`. This allows you to use Upstash's embedding models for vectorization. + +```python +import os +from mem0 import Memory + +os.environ["UPSTASH_VECTOR_REST_URL"] = "..." +os.environ["UPSTASH_VECTOR_REST_TOKEN"] = "..." + +config = { + "vector_store": { + "provider": "upstash_vector", + "enable_embeddings": True, + } +} + +m = Memory.from_config(config) +m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"}) +``` + + + Setting `enable_embeddings` to `True` will bypass any external embedding provider you have configured. + + +### Usage with external embedding providers + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "..." +os.environ["UPSTASH_VECTOR_REST_URL"] = "..." +os.environ["UPSTASH_VECTOR_REST_TOKEN"] = "..." + +config = { + "vector_store": { + "provider": "upstash_vector", + }, + "embedder": { + "provider": "openai", + "config": { + "model": "text-embedding-3-large" + }, + } +} + +m = Memory.from_config(config) +m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"}) +``` + +### Config + +Here are the parameters available for configuring Upstash Vector: + +| Parameter | Description | Default Value | +| ------------------- | ---------------------------------- | ------------- | +| `url` | URL for the Upstash Vector index | `None` | +| `token` | Token for the Upstash Vector index | `None` | +| `client` | An `upstash_vector.Index` instance | `None` | +| `collection_name` | The default namespace used | `""` | +| `enable_embeddings` | Whether to use Upstash embeddings | `False` | + + + When `url` and `token` are not provided, the `UPSTASH_VECTOR_REST_URL` and + `UPSTASH_VECTOR_REST_TOKEN` environment variables are used. + diff --git a/docs/v0x/components/vectordbs/dbs/valkey.mdx b/docs/v0x/components/vectordbs/dbs/valkey.mdx new file mode 100644 index 000000000..3c6d72e84 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/valkey.mdx @@ -0,0 +1,49 @@ +# Valkey Vector Store + +[Valkey](https://valkey.io/) is an open source (BSD) high-performance key/value datastore that supports a variety of workloads and rich datastructures including vector search. + +## Installation + +```bash +pip install mem0ai[vector_stores] +``` + +## Usage + +```python +config = { + "vector_store": { + "provider": "valkey", + "config": { + "collection_name": "test", + "valkey_url": "valkey://localhost:6379", + "embedding_model_dims": 1536, + "index_type": "flat" + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +## Parameters + +Let's see the available parameters for the `valkey` config: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `collection_name` | The name of the collection to store the vectors | `mem0` | +| `valkey_url` | Connection URL for the Valkey server | `valkey://localhost:6379` | +| `embedding_model_dims` | Dimensions of the embedding model | `1536` | +| `index_type` | Vector index algorithm (`hnsw` or `flat`) | `hnsw` | +| `hnsw_m` | Number of bi-directional links for HNSW | `16` | +| `hnsw_ef_construction` | Size of dynamic candidate list for HNSW | `200` | +| `hnsw_ef_runtime` | Size of dynamic candidate list for search | `10` | +| `distance_metric` | Distance metric for vector similarity | `cosine` | diff --git a/docs/v0x/components/vectordbs/dbs/vectorize.mdx b/docs/v0x/components/vectordbs/dbs/vectorize.mdx new file mode 100644 index 000000000..de5205291 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/vectorize.mdx @@ -0,0 +1,45 @@ +[Cloudflare Vectorize](https://developers.cloudflare.com/vectorize/) is a vector database offering from Cloudflare, allowing you to build AI-powered applications with vector embeddings. + +### Usage + + +```typescript TypeScript +import { Memory } from 'mem0ai/oss'; + +const config = { + vectorStore: { + provider: 'vectorize', + config: { + indexName: 'my-memory-index', + accountId: 'your-cloudflare-account-id', + apiKey: 'your-cloudflare-api-key', + dimension: 1536, // Optional: defaults to 1536 + }, + }, +}; + +const memory = new Memory(config); +const messages = [ + {"role": "user", "content": "I'm looking for a good book to read."}, + {"role": "assistant", "content": "Sure, what genre are you interested in?"}, + {"role": "user", "content": "I enjoy fantasy novels with strong world-building."}, + {"role": "assistant", "content": "Great! I'll keep that in mind for future recommendations."} +] +await memory.add(messages, { userId: "bob", metadata: { interest: "books" } }); +``` + + +### Config + +Let's see the available parameters for the `vectorize` config: + + + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `indexName` | The name of the Vectorize index | `None` (Required) | +| `accountId` | Your Cloudflare account ID | `None` (Required) | +| `apiKey` | Your Cloudflare API token | `None` (Required) | +| `dimension` | Dimensions of the embedding model | `1536` | + + diff --git a/docs/v0x/components/vectordbs/dbs/vertex_ai.mdx b/docs/v0x/components/vectordbs/dbs/vertex_ai.mdx new file mode 100644 index 000000000..637b4d98f --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/vertex_ai.mdx @@ -0,0 +1,48 @@ +--- +title: Vertex AI Vector Search +--- + + +### Usage + +To use Google Cloud Vertex AI Vector Search with `mem0`, you need to configure the `vector_store` in your `mem0` config: + + +```python +import os +from mem0 import Memory + +os.environ["GOOGLE_API_KEY"] = "sk-xx" + +config = { + "vector_store": { + "provider": "vertex_ai_vector_search", + "config": { + "endpoint_id": "YOUR_ENDPOINT_ID", # Required: Vector Search endpoint ID + "index_id": "YOUR_INDEX_ID", # Required: Vector Search index ID + "deployment_index_id": "YOUR_DEPLOYMENT_INDEX_ID", # Required: Deployment-specific ID + "project_id": "YOUR_PROJECT_ID", # Required: Google Cloud project ID + "project_number": "YOUR_PROJECT_NUMBER", # Required: Google Cloud project number + "region": "YOUR_REGION", # Optional: Defaults to GOOGLE_CLOUD_REGION + "credentials_path": "path/to/credentials.json", # Optional: Defaults to GOOGLE_APPLICATION_CREDENTIALS + "vector_search_api_endpoint": "YOUR_API_ENDPOINT" # Required for get operations + } + } +} +m = Memory.from_config(config) +m.add("Your text here", user_id="user", metadata={"category": "example"}) +``` + + +### Required Parameters + +| Parameter | Description | Required | +|-----------|-------------|----------| +| `endpoint_id` | Vector Search endpoint ID | Yes | +| `index_id` | Vector Search index ID | Yes | +| `deployment_index_id` | Deployment-specific index ID | Yes | +| `project_id` | Google Cloud project ID | Yes | +| `project_number` | Google Cloud project number | Yes | +| `vector_search_api_endpoint` | Vector search API endpoint | Yes (for get operations) | +| `region` | Google Cloud region | No (defaults to GOOGLE_CLOUD_REGION) | +| `credentials_path` | Path to service account credentials | No (defaults to GOOGLE_APPLICATION_CREDENTIALS) | diff --git a/docs/v0x/components/vectordbs/dbs/weaviate.mdx b/docs/v0x/components/vectordbs/dbs/weaviate.mdx new file mode 100644 index 000000000..f5c36f4f4 --- /dev/null +++ b/docs/v0x/components/vectordbs/dbs/weaviate.mdx @@ -0,0 +1,47 @@ +[Weaviate](https://weaviate.io/) is an open-source vector search engine. It allows efficient storage and retrieval of high-dimensional vector embeddings, enabling powerful search and retrieval capabilities. + + +### Installation +```bash +pip install weaviate weaviate-client +``` + +### Usage + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "sk-xx" + +config = { + "vector_store": { + "provider": "weaviate", + "config": { + "collection_name": "test", + "cluster_url": "http://localhost:8080", + "auth_client_secret": None, + } + } +} + +m = Memory.from_config(config) +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movie? They can be quite engaging."}, + {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] +m.add(messages, user_id="alice", metadata={"category": "movies"}) +``` + +### Config + +Let's see the available parameters for the `weaviate` config: + +| Parameter | Description | Default Value | +| --- | --- | --- | +| `collection_name` | The name of the collection to store the vectors | `mem0` | +| `embedding_model_dims` | Dimensions of the embedding model | `1536` | +| `cluster_url` | URL for the Weaviate server | `None` | +| `auth_client_secret` | API key for Weaviate authentication | `None` | \ No newline at end of file diff --git a/docs/v0x/components/vectordbs/overview.mdx b/docs/v0x/components/vectordbs/overview.mdx new file mode 100644 index 000000000..ba504541c --- /dev/null +++ b/docs/v0x/components/vectordbs/overview.mdx @@ -0,0 +1,55 @@ +--- +title: Overview +icon: "info" +iconType: "solid" +--- + +Mem0 includes built-in support for various popular databases. Memory can utilize the database provided by the user, ensuring efficient use for specific needs. + +## Supported Vector Databases + +See the list of supported vector databases below. + + + The following vector databases are supported in the Python implementation. The TypeScript implementation currently only supports Qdrant, Redis, Valkey, Vectorize and in-memory vector database. + + + + + + + + + + + + + + + + + + + + + + + + +## Usage + +To utilize a vector database, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `Qdrant` will be used as the vector database. + +For a comprehensive list of available parameters for vector database configuration, please refer to [Config](./config). + +## Common issues + +### Using model with different dimensions + +If you are using customized model, which is having different dimensions other than 1536 +for example 768, you may encounter below error: + +`ValueError: shapes (0,1536) and (768,) not aligned: 1536 (dim 1) != 768 (dim 0)` + +you could add `"embedding_model_dims": 768,` to the config of the vector_store to overcome this issue. + diff --git a/docs/v0x/core-concepts/memory-operations/add.mdx b/docs/v0x/core-concepts/memory-operations/add.mdx new file mode 100644 index 000000000..37305b39d --- /dev/null +++ b/docs/v0x/core-concepts/memory-operations/add.mdx @@ -0,0 +1,153 @@ +--- +title: Add Memory +description: Add memory into the Mem0 platform by storing user-assistant interactions and facts for later retrieval. +icon: "plus" +iconType: "solid" +--- + + +## Overview + +The `add` operation is how you store memory into Mem0. Whether you're working with a chatbot, a voice assistant, or a multi-agent system, this is the entry point to create long-term memory. + +Memories typically come from a **user-assistant interaction** and Mem0 handles the extraction, transformation, and storage for you. + +Mem0 offers two implementation flows: + +- **Mem0 Platform** (Managed, scalable, with dashboard + API) +- **Mem0 Open Source** (Lightweight, fully local, flexible SDKs) + +Each supports the same core memory operations, but with slightly different setup. Below, we walk through examples for both. + + +## Architecture + + + + + +When you call `add`, Mem0 performs the following steps under the hood: + +1. **Information Extraction** + The input messages are passed through an LLM that extracts key facts, decisions, preferences, or events worth remembering. + +2. **Conflict Resolution** + Mem0 compares the new memory against existing ones to detect duplication or contradiction and handles updates accordingly. + +3. **Memory Storage** + The result is stored in a vector database (for semantic search) and optionally in a graph structure (for relationship mapping). + +You don’t need to handle any of this manually, Mem0 takes care of it with a single API call or SDK method. + +--- + +## Example: Mem0 Platform + + +```python Python +from mem0 import MemoryClient + +client = MemoryClient(api_key="your-api-key") + +messages = [ + {"role": "user", "content": "I'm planning a trip to Tokyo next month."}, + {"role": "assistant", "content": "Great! I’ll remember that for future suggestions."} +] + +client.add( + messages=messages, + user_id="alice", + version="v2" +) +``` + +```javascript JavaScript +import { MemoryClient } from "mem0ai"; + +const client = new MemoryClient({apiKey: "your-api-key"}); + +const messages = [ + { role: "user", content: "I'm planning a trip to Tokyo next month." }, + { role: "assistant", content: "Great! I’ll remember that for future suggestions." } +]; + +await client.add({ + messages, + user_id: "alice", + version: "v2" +}); +``` + + +--- + +## Example: Mem0 Open Source + + +```python Python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" + +m = Memory() + +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] + +# Store inferred memories (default behavior) +result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"}) + +# Optionally store raw messages without inference +result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"}, infer=False) +``` + +```javascript JavaScript +import { Memory } from 'mem0ai/oss'; + +const memory = new Memory(); + +const messages = [ + { + role: "user", + content: "I like to drink coffee in the morning and go for a walk" + } +]; + +const result = memory.add(messages, { + userId: "alice", + metadata: { category: "preferences" } +}); +``` + + +--- + +## When Should You Add Memory? + +Add memory whenever your agent learns something useful: + +- A new user preference is shared +- A decision or suggestion is made +- A goal or task is completed +- A new entity is introduced +- A user gives feedback or clarification + +Storing this context allows the agent to reason better in future interactions. + + +### More Details + +For full list of supported fields, required formats, and advanced options, see the +[Add Memory API Reference](/api-reference/memory/add-memories). + +--- + +## Need help? +If you have any questions, please feel free to reach out to us using one of the following methods: + + \ No newline at end of file diff --git a/docs/v0x/core-concepts/memory-operations/delete.mdx b/docs/v0x/core-concepts/memory-operations/delete.mdx new file mode 100644 index 000000000..bdfd35637 --- /dev/null +++ b/docs/v0x/core-concepts/memory-operations/delete.mdx @@ -0,0 +1,141 @@ +--- +title: Delete Memory +description: Remove memories from Mem0 either individually, in bulk, or via filters. +icon: "trash" +iconType: "solid" +--- + +## Overview + +Memories can become outdated, irrelevant, or need to be removed for privacy or compliance reasons. Mem0 offers flexible ways to delete memory: + +1. **Delete a Single Memory**: Using a specific memory ID +2. **Batch Delete**: Delete multiple known memory IDs (up to 1000) +3. **Filtered Delete**: Delete memories matching a filter (e.g., `user_id`, `metadata`, `run_id`) + +This page walks through code example for each method. + + +## Use Cases + +- Forget a user’s past preferences by request +- Remove outdated or incorrect memory entries +- Clean up memory after session expiration +- Comply with data deletion requests (e.g., GDPR) + +--- + +## 1. Delete a Single Memory by ID + + +```python Python +from mem0 import MemoryClient + +client = MemoryClient(api_key="your-api-key") + +memory_id = "your_memory_id" +client.delete(memory_id=memory_id) +``` + +```javascript JavaScript +import MemoryClient from 'mem0ai'; + +const client = new MemoryClient({ apiKey: "your-api-key" }); + +client.delete("your_memory_id") + .then(result => console.log(result)) + .catch(error => console.error(error)); +``` + + +--- + +## 2. Batch Delete Multiple Memories + + +```python Python +from mem0 import MemoryClient + +client = MemoryClient(api_key="your-api-key") + +delete_memories = [ + {"memory_id": "id1"}, + {"memory_id": "id2"} +] + +response = client.batch_delete(delete_memories) +print(response) +``` + +```javascript JavaScript +import MemoryClient from 'mem0ai'; + +const client = new MemoryClient({ apiKey: "your-api-key" }); + +const deleteMemories = [ + { memory_id: "id1" }, + { memory_id: "id2" } +]; + +client.batchDelete(deleteMemories) + .then(response => console.log('Batch delete response:', response)) + .catch(error => console.error(error)); +``` + + +--- + +## 3. Delete Memories by Filter (e.g., user_id) + + +```python Python +from mem0 import MemoryClient + +client = MemoryClient(api_key="your-api-key") + +# Delete all memories for a specific user +client.delete_all(user_id="alice") +``` + +```javascript JavaScript +import MemoryClient from 'mem0ai'; + +const client = new MemoryClient({ apiKey: "your-api-key" }); + +client.deleteAll({ user_id: "alice" }) + .then(result => console.log(result)) + .catch(error => console.error(error)); +``` + + +You can also filter by other parameters such as: +- `agent_id` +- `run_id` +- `metadata` (as JSON string) + +--- + +## Key Differences + +| Method | Use When | IDs Needed | Filters | +|----------------------|-------------------------------------------|------------|----------| +| `delete(memory_id)` | You know exactly which memory to remove | ✔ | ✘ | +| `batch_delete([...])`| You have a known list of memory IDs | ✔ | ✘ | +| `delete_all(...)` | You want to delete by user/agent/run/etc | ✘ | ✔ | + + +### More Details + +For request/response schema and additional filtering options, see: +- [Delete Memory API Reference](/api-reference/memory/delete-memory) +- [Batch Delete API Reference](/api-reference/memory/batch-delete) +- [Delete Memories by Filter Reference](/api-reference/memory/delete-memories) + +You’ve now seen how to add, search, update, and delete memories in Mem0. + +--- + +## Need help? +If you have any questions, please feel free to reach out to us using one of the following methods: + + diff --git a/docs/v0x/core-concepts/memory-operations/search.mdx b/docs/v0x/core-concepts/memory-operations/search.mdx new file mode 100644 index 000000000..496c1eb00 --- /dev/null +++ b/docs/v0x/core-concepts/memory-operations/search.mdx @@ -0,0 +1,124 @@ +--- +title: Search Memory +description: Retrieve relevant memories from Mem0 using powerful semantic and filtered search capabilities. +icon: "magnifying-glass" +iconType: "solid" +--- + +## Overview + +The `search` operation allows you to retrieve relevant memories based on a natural language query and optional filters like user ID, agent ID, categories, and more. This is the foundation of giving your agents memory-aware behavior. + +Mem0 supports: +- Semantic similarity search +- Metadata filtering (with advanced logic) +- Reranking and thresholds +- Cross-agent, multi-session context resolution + +This applies to both: +- **Mem0 Platform** (hosted API with full-scale features) +- **Mem0 Open Source** (local-first with LLM inference and local vector DB) + + +## Architecture + + + + + +The search flow follows these steps: + +1. **Query Processing** + An LLM refines and optimizes your natural language query. + +2. **Vector Search** + Semantic embeddings are used to find the most relevant memories using cosine similarity. + +3. **Filtering & Ranking** + Logical and comparison-based filters are applied. Memories are scored, filtered, and optionally reranked. + +4. **Results Delivery** + Relevant memories are returned with associated metadata and timestamps. + +--- + +## Example: Mem0 Platform + + +```python Python +from mem0 import MemoryClient + +client = MemoryClient(api_key="your-api-key") + +query = "What do you know about me?" +filters = { + "OR": [ + {"user_id": "alice"}, + {"agent_id": {"in": ["travel-assistant", "customer-support"]}} + ] +} + +results = client.search(query, version="v2", filters=filters) +``` + +```javascript JavaScript +import { MemoryClient } from "mem0ai"; + +const client = new MemoryClient({apiKey: "your-api-key"}); + +const query = "I'm craving some pizza. Any recommendations?"; +const filters = { + AND: [ + { user_id: "alice" } + ] +}; + +const results = await client.search(query, { + version: "v2", + filters +}); +``` + + +--- + +## Example: Mem0 Open Source + + +```python Python +from mem0 import Memory + +m = Memory() +related_memories = m.search("Should I drink coffee or tea?", user_id="alice") +``` + +```javascript JavaScript +import { Memory } from 'mem0ai/oss'; + +const memory = new Memory(); +const relatedMemories = memory.search("Should I drink coffee or tea?", { userId: "alice" }); +``` + + +--- + +## Tips for Better Search + +- Use descriptive natural queries (Mem0 can interpret intent) +- Apply filters for scoped, faster lookup +- Use `version: "v2"` for enhanced results +- Consider wildcard filters (e.g., `run_id: "*"`) for broader matches +- Tune with `top_k`, `threshold`, or `rerank` if needed + + +### More Details + +For the full list of filter logic, comparison operators, and optional search parameters, see the +[Search Memory API Reference](/api-reference/memory/v2-search-memories). + +--- + +## Need help? +If you have any questions, please feel free to reach out to us using one of the following methods: + + diff --git a/docs/v0x/core-concepts/memory-operations/update.mdx b/docs/v0x/core-concepts/memory-operations/update.mdx new file mode 100644 index 000000000..94d22c3aa --- /dev/null +++ b/docs/v0x/core-concepts/memory-operations/update.mdx @@ -0,0 +1,117 @@ +--- +title: Update Memory +description: Modify an existing memory by updating its content or metadata. +icon: "pencil" +iconType: "solid" +--- + +## Overview + +User preferences, interests, and behaviors often evolve over time. The `update` operation lets you revise a stored memory, whether it's updating facts and memories, rephrasing a message, or enriching metadata. + +Mem0 supports both: +- **Single Memory Update** for one specific memory using its ID +- **Batch Update** for updating many memories at once (up to 1000) + +This guide includes usage for both single update and batch update of memories through **Mem0 Platform** + + +## Use Cases + +- Refine a vague or incorrect memory after a correction +- Add or edit memory with new metadata (e.g., categories, tags) +- Evolve factual knowledge as the user’s profile changes +- A user profile evolves: “I love spicy food” → later says “Actually, I can’t handle spicy food.” + +Updating memory ensures your agents remain accurate, adaptive, and personalized. + +--- + +## Update Memory + + +```python Python +from mem0 import MemoryClient + +client = MemoryClient(api_key="your-api-key") + +memory_id = "your_memory_id" +client.update( + memory_id=memory_id, + text="Updated memory content about the user", + metadata={"category": "profile-update"} +) +``` + +```javascript JavaScript +import MemoryClient from 'mem0ai'; + +const client = new MemoryClient({ apiKey: "your-api-key" }); +const memory_id = "your_memory_id"; + +client.update(memory_id, { + text: "Updated memory content about the user", + metadata: { category: "profile-update" } +}) + .then(result => console.log(result)) + .catch(error => console.error(error)); +``` + + +--- + +## Batch Update + +Update up to 1000 memories in one call. + + +```python Python +from mem0 import MemoryClient + +client = MemoryClient(api_key="your-api-key") + +update_memories = [ + {"memory_id": "id1", "text": "Watches football"}, + {"memory_id": "id2", "text": "Likes to travel"} +] + +response = client.batch_update(update_memories) +print(response) +``` + +```javascript JavaScript +import MemoryClient from 'mem0ai'; + +const client = new MemoryClient({ apiKey: "your-api-key" }); + +const updateMemories = [ + { memoryId: "id1", text: "Watches football" }, + { memoryId: "id2", text: "Likes to travel" } +]; + +client.batchUpdate(updateMemories) + .then(response => console.log('Batch update response:', response)) + .catch(error => console.error(error)); +``` + + +--- + +## Tips + +- You can update both `text` and `metadata` in the same call. +- Use `batchUpdate` when you're applying similar corrections at scale. +- If memory is marked `immutable`, it must first be deleted and re-added. +- Combine this with feedback mechanisms (e.g., user thumbs-up/down) to self-improve memory. + + +### More Details + +Refer to the full [Update Memory API Reference](/api-reference/memory/update-memory) and [Batch Update Reference](/api-reference/memory/batch-update) for schema and advanced fields. + +--- + +## Need help? +If you have any questions, please feel free to reach out to us using one of the following methods: + + diff --git a/docs/v0x/core-concepts/memory-types.mdx b/docs/v0x/core-concepts/memory-types.mdx new file mode 100644 index 000000000..18d10a530 --- /dev/null +++ b/docs/v0x/core-concepts/memory-types.mdx @@ -0,0 +1,49 @@ +--- +title: Memory Types +description: Understanding different types of memory in AI Applications +icon: "memory" +iconType: "solid" +--- + +To build useful AI applications, we need to understand how different memory systems work together. This guide explores the fundamental types of memory in AI systems and shows how Mem0 implements these concepts. + +## Why Memory Matters + +AI systems need memory for three key purposes: +1. Maintaining context during conversations +2. Learning from past interactions +3. Building personalized experiences over time + +Without proper memory systems, AI applications would treat each interaction as completely new, losing valuable context and personalization opportunities. + +## Short-Term Memory + +The most basic form of memory in AI systems holds immediate context - like a person remembering what was just said in a conversation. This includes: + +- **Conversation History**: Recent messages and their order +- **Working Memory**: Temporary variables and state +- **Attention Context**: Current focus of the conversation + +## Long-Term Memory + +More sophisticated AI applications implement long-term memory to retain information across conversations. This includes: + +- **Factual Memory**: Stored knowledge about users, preferences, and domain-specific information +- **Episodic Memory**: Past interactions and experiences +- **Semantic Memory**: Understanding of concepts and their relationships + +## Memory Characteristics + +Each memory type has distinct characteristics: + +| Type | Persistence | Access Speed | Use Case | +|------|-------------|--------------|-----------| +| Short-Term | Temporary | Instant | Active conversations | +| Long-Term | Persistent | Fast | User preferences and history | + +## How Mem0 Implements Long-Term Memory +Mem0's long-term memory system builds on these foundations by: + +1. Using vector embeddings to store and retrieve semantic information +2. Maintaining user-specific context across sessions +3. Implementing efficient retrieval mechanisms for relevant past interactions \ No newline at end of file diff --git a/docs/v0x/examples/ai_companion_js.mdx b/docs/v0x/examples/ai_companion_js.mdx new file mode 100644 index 000000000..d170d12bd --- /dev/null +++ b/docs/v0x/examples/ai_companion_js.mdx @@ -0,0 +1,126 @@ +--- +title: AI Companion in Node.js +--- + +You can create a personalised AI Companion using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started. + +## Overview + +The Personalized AI Companion leverages Mem0 to retain information across interactions, enabling a tailored learning experience. It creates memories for each user interaction and integrates with OpenAI's GPT models to provide detailed and context-aware responses to user queries. + +## Setup + +Before you begin, ensure you have Node.js installed and create a new project. Install the required dependencies using npm: + +```bash +npm install openai mem0ai +``` + +## Full Code Example + +Below is the complete code to create and interact with an AI Companion using Mem0: + +```javascript +import { OpenAI } from 'openai'; +import { Memory } from 'mem0ai/oss'; +import * as readline from 'readline'; + +const openaiClient = new OpenAI(); +const memory = new Memory(); + +async function chatWithMemories(message, userId = "default_user") { + const relevantMemories = await memory.search(message, { userId: userId }); + + const memoriesStr = relevantMemories.results + .map(entry => `- ${entry.memory}`) + .join('\n'); + + const systemPrompt = `You are a helpful AI. Answer the question based on query and memories. +User Memories: +${memoriesStr}`; + + const messages = [ + { role: "system", content: systemPrompt }, + { role: "user", content: message } + ]; + + const response = await openaiClient.chat.completions.create({ + model: "gpt-4o-mini", + messages: messages + }); + + const assistantResponse = response.choices[0].message.content || ""; + + messages.push({ role: "assistant", content: assistantResponse }); + await memory.add(messages, { userId: userId }); + + return assistantResponse; +} + +async function main() { + const rl = readline.createInterface({ + input: process.stdin, + output: process.stdout + }); + + console.log("Chat with AI (type 'exit' to quit)"); + + const askQuestion = () => { + return new Promise((resolve) => { + rl.question("You: ", (input) => { + resolve(input.trim()); + }); + }); + }; + + try { + while (true) { + const userInput = await askQuestion(); + + if (userInput.toLowerCase() === 'exit') { + console.log("Goodbye!"); + rl.close(); + break; + } + + const response = await chatWithMemories(userInput, "sample_user"); + console.log(`AI: ${response}`); + } + } catch (error) { + console.error("An error occurred:", error); + rl.close(); + } +} + +main().catch(console.error); +``` + +### Key Components + +1. **Initialization** + - The code initializes both OpenAI and Mem0 Memory clients + - Uses Node.js's built-in readline module for command-line interaction + +2. **Memory Management (chatWithMemories function)** + - Retrieves relevant memories using Mem0's search functionality + - Constructs a system prompt that includes past memories + - Makes API calls to OpenAI for generating responses + - Stores new interactions in memory + +3. **Interactive Chat Interface (main function)** + - Creates a command-line interface for user interaction + - Handles user input and displays AI responses + - Includes graceful exit functionality + +### Environment Setup + +Make sure to set up your environment variables: +```bash +export OPENAI_API_KEY=your_api_key +``` + +### Conclusion + +This implementation demonstrates how to create an AI Companion that maintains context across conversations using Mem0's memory capabilities. The system automatically stores and retrieves relevant information, creating a more personalized and context-aware interaction experience. + +As users interact with the system, Mem0's memory system continuously learns and adapts, making future responses more relevant and personalized. This setup is ideal for creating long-term learning AI assistants that can maintain context and provide increasingly personalized responses over time. diff --git a/docs/v0x/examples/aws_example.mdx b/docs/v0x/examples/aws_example.mdx new file mode 100644 index 000000000..cdd121edd --- /dev/null +++ b/docs/v0x/examples/aws_example.mdx @@ -0,0 +1,130 @@ +--- +title: "Amazon Stack: AWS Bedrock, AOSS, and Neptune Analytics" +--- + +This example demonstrates how to configure and use the `mem0ai` SDK with **AWS Bedrock**, **OpenSearch Service (AOSS)**, and **AWS Neptune Analytics** for persistent memory capabilities in Python. + +## Installation + +Install the required dependencies to include the Amazon data stack, including **boto3**, **opensearch-py**, and **langchain-aws**: + +```bash +pip install "mem0ai[graph,extras]" +``` + +## Environment Setup + +Set your AWS environment variables: + +```python +import os + +# Set these in your environment or notebook +os.environ['AWS_REGION'] = 'us-west-2' +os.environ['AWS_ACCESS_KEY_ID'] = 'AK00000000000000000' +os.environ['AWS_SECRET_ACCESS_KEY'] = 'AS00000000000000000' + +# Confirm they are set +print(os.environ['AWS_REGION']) +print(os.environ['AWS_ACCESS_KEY_ID']) +print(os.environ['AWS_SECRET_ACCESS_KEY']) +``` + +## Configuration and Usage + +This sets up Mem0 with: +- [AWS Bedrock for LLM](https://docs.mem0.ai/components/llms/models/aws_bedrock) +- [AWS Bedrock for embeddings](https://docs.mem0.ai/components/embedders/models/aws_bedrock#aws-bedrock) +- [OpenSearch as the vector store](https://docs.mem0.ai/components/vectordbs/dbs/opensearch) +- [Neptune Analytics as your graph store](https://docs.mem0.ai/open-source/graph_memory/overview#initialize-neptune-analytics). + +```python +import boto3 +from opensearchpy import RequestsHttpConnection, AWSV4SignerAuth +from mem0.memory.main import Memory + +region = 'us-west-2' +service = 'aoss' +credentials = boto3.Session().get_credentials() +auth = AWSV4SignerAuth(credentials, region, service) + +config = { + "embedder": { + "provider": "aws_bedrock", + "config": { + "model": "amazon.titan-embed-text-v2:0" + } + }, + "llm": { + "provider": "aws_bedrock", + "config": { + "model": "us.anthropic.claude-3-7-sonnet-20250219-v1:0", + "temperature": 0.1, + "max_tokens": 2000 + } + }, + "vector_store": { + "provider": "opensearch", + "config": { + "collection_name": "mem0", + "host": "your-opensearch-domain.us-west-2.es.amazonaws.com", + "port": 443, + "http_auth": auth, + "connection_class": RequestsHttpConnection, + "pool_maxsize": 20, + "use_ssl": True, + "verify_certs": True, + "embedding_model_dims": 1024, + } + }, + "graph_store": { + "provider": "neptune", + "config": { + "endpoint": f"neptune-graph://my-graph-identifier", + }, + }, +} + +# Initialize the memory system +m = Memory.from_config(config) +``` + +## Usage + +Reference [Notebook example](https://github.com/mem0ai/mem0/blob/main/examples/graph-db-demo/neptune-example.ipynb) + +#### Add a memory: + +```python +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] + +# Store inferred memories (default behavior) +result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"}) +``` + +#### Search a memory: +```python +relevant_memories = m.search(query, user_id="alice") +``` + +#### Get all memories: +```python +all_memories = m.get_all(user_id="alice") +``` + +#### Get a specific memory: +```python +memory = m.get(memory_id) +``` + + +--- + +## Conclusion + +With Mem0 and AWS services like Bedrock, OpenSearch, and Neptune Analytics, you can build intelligent AI companions that remember, adapt, and personalize their responses over time. This makes them ideal for long-term assistants, tutors, or support bots with persistent memory and natural conversation abilities. diff --git a/docs/v0x/examples/aws_neptune_analytics_hybrid_store.mdx b/docs/v0x/examples/aws_neptune_analytics_hybrid_store.mdx new file mode 100644 index 000000000..617be26d4 --- /dev/null +++ b/docs/v0x/examples/aws_neptune_analytics_hybrid_store.mdx @@ -0,0 +1,120 @@ +--- +title: "Amazon Stack - Neptune Analytics Hybrid Store: AWS Bedrock and Neptune Analytics" +--- + +This example demonstrates how to configure and use the `mem0ai` SDK with **AWS Bedrock** and **AWS Neptune Analytics** for persistent memory capabilities in Python. + +## Installation + +Install the required dependencies to include the Amazon data stack, including **boto3** and **langchain-aws**: + +```bash +pip install "mem0ai[graph,extras]" +``` + +## Environment Setup + +Set your AWS environment variables: + +```python +import os + +# Set these in your environment or notebook +os.environ['AWS_REGION'] = 'us-west-2' +os.environ['AWS_ACCESS_KEY_ID'] = 'AK00000000000000000' +os.environ['AWS_SECRET_ACCESS_KEY'] = 'AS00000000000000000' + +# Confirm they are set +print(os.environ['AWS_REGION']) +print(os.environ['AWS_ACCESS_KEY_ID']) +print(os.environ['AWS_SECRET_ACCESS_KEY']) +``` + +## Configuration and Usage + +This sets up Mem0 with: +- [AWS Bedrock for LLM](https://docs.mem0.ai/components/llms/models/aws_bedrock) +- [AWS Bedrock for embeddings](https://docs.mem0.ai/components/embedders/models/aws_bedrock#aws-bedrock) +- [Neptune Analytics as the vector store](https://docs.mem0.ai/components/vectordbs/dbs/neptune_analytics) +- [Neptune Analytics as the graph store](https://docs.mem0.ai/open-source/graph_memory/overview#initialize-neptune-analytics). + +```python +import boto3 +from mem0.memory.main import Memory + +region = 'us-west-2' +neptune_analytics_endpoint = 'neptune-graph://my-graph-identifier' + +config = { + "embedder": { + "provider": "aws_bedrock", + "config": { + "model": "amazon.titan-embed-text-v2:0" + } + }, + "llm": { + "provider": "aws_bedrock", + "config": { + "model": "us.anthropic.claude-3-7-sonnet-20250219-v1:0", + "temperature": 0.1, + "max_tokens": 2000 + } + }, + "vector_store": { + "provider": "neptune", + "config": { + "collection_name": "mem0", + "endpoint": neptune_analytics_endpoint, + }, + }, + "graph_store": { + "provider": "neptune", + "config": { + "endpoint": neptune_analytics_endpoint, + }, + }, +} + +# Initialize the memory system +m = Memory.from_config(config) +``` + +## Usage + +Reference [Notebook example](https://github.com/mem0ai/mem0/blob/main/examples/graph-db-demo/neptune-example.ipynb) + +#### Add a memory: + +```python +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] + +# Store inferred memories (default behavior) +result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"}) +``` + +#### Search a memory: +```python +relevant_memories = m.search(query, user_id="alice") +``` + +#### Get all memories: +```python +all_memories = m.get_all(user_id="alice") +``` + +#### Get a specific memory: +```python +memory = m.get(memory_id) +``` + + +--- + +## Conclusion + +With Mem0 and AWS services like Bedrock and Neptune Analytics, you can build intelligent AI companions that remember, adapt, and personalize their responses over time. This makes them ideal for long-term assistants, tutors, or support bots with persistent memory and natural conversation abilities. diff --git a/docs/v0x/examples/chrome-extension.mdx b/docs/v0x/examples/chrome-extension.mdx new file mode 100644 index 000000000..a9ed8e3d1 --- /dev/null +++ b/docs/v0x/examples/chrome-extension.mdx @@ -0,0 +1,55 @@ +# Mem0 Chrome Extension + +Enhance your AI interactions with **Mem0**, a Chrome extension that introduces a universal memory layer across platforms like `ChatGPT`, `Claude`, and `Perplexity`. Mem0 ensures seamless context sharing, making your AI experiences more personalized and efficient. + + + 🎉 We now support Grok! The Mem0 Chrome Extension has been updated to work with Grok, bringing the same powerful memory capabilities to your Grok conversations. + + + +## Features + +- **Universal Memory Layer**: Share context seamlessly across ChatGPT, Claude, Perplexity, and Grok. +- **Smart Context Detection**: Automatically captures relevant information from your conversations. +- **Intelligent Memory Retrieval**: Surfaces pertinent memories at the right time. +- **One-Click Sync**: Easily synchronize with existing ChatGPT memories. +- **Memory Dashboard**: Manage all your memories in one centralized location. + +## Installation + +You can install the Mem0 Chrome Extension using one of the following methods: + +### Method 1: Chrome Web Store Installation + +1. **Download the Extension**: Open Google Chrome and navigate to the [Mem0 Chrome Extension page](https://chromewebstore.google.com/detail/mem0/onihkkbipkfeijkadecaafbgagkhglop?hl=en). +2. **Add to Chrome**: Click on the "Add to Chrome" button. +3. **Confirm Installation**: In the pop-up dialog, click "Add extension" to confirm. The Mem0 icon should now appear in your Chrome toolbar. + +### Method 2: Manual Installation + +1. **Download the Extension**: Clone or download the extension files from the [Mem0 Chrome Extension GitHub repository](https://github.com/mem0ai/mem0-chrome-extension). +2. **Access Chrome Extensions**: Open Google Chrome and navigate to `chrome://extensions`. +3. **Enable Developer Mode**: Toggle the "Developer mode" switch in the top right corner. +4. **Load Unpacked Extension**: Click "Load unpacked" and select the directory containing the extension files. +5. **Confirm Installation**: The Mem0 Chrome Extension should now appear in your Chrome toolbar. + +## Usage + +1. **Locate the Mem0 Icon**: After installation, find the Mem0 icon in your Chrome toolbar. +2. **Sign In**: Click the icon and sign in with your Google account. +3. **Interact with AI Assistants**: + - **ChatGPT and Perplexity**: Continue your conversations as usual; Mem0 operates seamlessly in the background. + - **Claude**: Click the Mem0 button or use the shortcut `Ctrl + M` to activate memory functions. + +## Configuration + +- **API Key**: Obtain your API key from the Mem0 Dashboard to connect the extension to the Mem0 API. +- **User ID**: This is your unique identifier in the Mem0 system. If not provided, it defaults to 'chrome-extension-user'. + +## Demo Video + + + +## Privacy and Data Security + +Your messages are sent to the Mem0 API for extracting and retrieving memories. Mem0 is committed to ensuring your data's privacy and security. diff --git a/docs/v0x/examples/collaborative-task-agent.mdx b/docs/v0x/examples/collaborative-task-agent.mdx new file mode 100644 index 000000000..c46e8881f --- /dev/null +++ b/docs/v0x/examples/collaborative-task-agent.mdx @@ -0,0 +1,123 @@ +--- +title: Multi-User Collaboration with Mem0 +--- + +## Overview + +Build a multi-user collaborative chat or task management system with Mem0. Each message is attributed to its author, and all messages are stored in a shared project space. Mem0 makes it easy to track contributions, sort and group messages, and collaborate in real time. + +## Setup + +Install the required packages: + +```bash +pip install openai mem0ai +``` + +## Full Code Example + +```python +from openai import OpenAI +from mem0 import Memory +import os +from datetime import datetime +from collections import defaultdict + +# Set your OpenAI API key +os.environ["OPENAI_API_KEY"] = "sk-your-key" + +# Shared project context +RUN_ID = "project-demo" + +# Initialize Mem0 +mem = Memory() + +class CollaborativeAgent: + def __init__(self, run_id): + self.run_id = run_id + self.mem = mem + + def add_message(self, role, name, content): + msg = {"role": role, "name": name, "content": content} + self.mem.add([msg], run_id=self.run_id, infer=False) + + def brainstorm(self, prompt): + # Get recent messages for context + memories = self.mem.search(prompt, run_id=self.run_id, limit=5)["results"] + context = "\n".join(f"- {m['memory']} (by {m.get('actor_id', 'Unknown')})" for m in memories) + client = OpenAI() + messages = [ + {"role": "system", "content": "You are a helpful project assistant."}, + {"role": "user", "content": f"Prompt: {prompt}\nContext:\n{context}"} + ] + reply = client.chat.completions.create( + model="gpt-4o-mini", + messages=messages + ).choices[0].message.content.strip() + self.add_message("assistant", "assistant", reply) + return reply + + def get_all_messages(self): + return self.mem.get_all(run_id=self.run_id)["results"] + + def print_sorted_by_time(self): + messages = self.get_all_messages() + messages.sort(key=lambda m: m.get('created_at', '')) + print("\n--- Messages (sorted by time) ---") + for m in messages: + who = m.get("actor_id") or "Unknown" + ts = m.get('created_at', 'Timestamp N/A') + try: + dt = datetime.fromisoformat(ts.replace('Z', '+00:00')) + ts_fmt = dt.strftime('%Y-%m-%d %H:%M:%S') + except Exception: + ts_fmt = ts + print(f"[{ts_fmt}] [{who}] {m['memory']}") + + def print_grouped_by_actor(self): + messages = self.get_all_messages() + grouped = defaultdict(list) + for m in messages: + grouped[m.get("actor_id") or "Unknown"].append(m) + print("\n--- Messages (grouped by actor) ---") + for actor, mems in grouped.items(): + print(f"\n=== {actor} ===") + for m in mems: + ts = m.get('created_at', 'Timestamp N/A') + try: + dt = datetime.fromisoformat(ts.replace('Z', '+00:00')) + ts_fmt = dt.strftime('%Y-%m-%d %H:%M:%S') + except Exception: + ts_fmt = ts + print(f"[{ts_fmt}] {m['memory']}") +``` + +## Usage + +```python +# Example usage +agent = CollaborativeAgent(RUN_ID) +agent.add_message("user", "alice", "Let's list tasks for the new landing page.") +agent.add_message("user", "bob", "I'll own the hero section copy.") +agent.add_message("user", "carol", "I'll choose product screenshots.") + +# Brainstorm with context +print("\nAssistant reply:\n", agent.brainstorm("What are the current open tasks?")) + +# Print all messages sorted by time +agent.print_sorted_by_time() + +# Print all messages grouped by actor +agent.print_grouped_by_actor() +``` + +## Key Points + +- Each message is attributed to a user or agent (actor) +- All messages are stored in a shared project space (`run_id`) +- You can sort messages by time, group by actor, and format timestamps for clarity +- Mem0 makes it easy to build collaborative, attributed chat/task systems + +## Conclusion + +Mem0 enables fast, transparent collaboration for teams and agents, with full attribution, flexible memory search, and easy message organization. diff --git a/docs/v0x/examples/customer-support-agent.mdx b/docs/v0x/examples/customer-support-agent.mdx new file mode 100644 index 000000000..e7ff5c0c7 --- /dev/null +++ b/docs/v0x/examples/customer-support-agent.mdx @@ -0,0 +1,111 @@ +--- +title: Customer Support AI Agent +--- + + +You can create a personalized Customer Support AI Agent using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started. + +## Overview + +The Customer Support AI Agent leverages Mem0 to retain information across interactions, enabling a personalized and efficient support experience. + +## Setup + +Install the necessary packages using pip: + +```bash +pip install openai mem0ai +``` + +## Full Code Example + +Below is the simplified code to create and interact with a Customer Support AI Agent using Mem0: + +```python +import os +from openai import OpenAI +from mem0 import Memory + +# Set the OpenAI API key +os.environ['OPENAI_API_KEY'] = 'sk-xxx' + +class CustomerSupportAIAgent: + def __init__(self): + """ + Initialize the CustomerSupportAIAgent with memory configuration and OpenAI client. + """ + config = { + "vector_store": { + "provider": "qdrant", + "config": { + "host": "localhost", + "port": 6333, + } + }, + } + self.memory = Memory.from_config(config) + self.client = OpenAI() + self.app_id = "customer-support" + + def handle_query(self, query, user_id=None): + """ + Handle a customer query and store the relevant information in memory. + + :param query: The customer query to handle. + :param user_id: Optional user ID to associate with the memory. + """ + # Start a streaming chat completion request to the AI + stream = self.client.chat.completions.create( + model="gpt-4", + stream=True, + messages=[ + {"role": "system", "content": "You are a customer support AI agent."}, + {"role": "user", "content": query} + ] + ) + # Store the query in memory + self.memory.add(query, user_id=user_id, metadata={"app_id": self.app_id}) + + # Print the response from the AI in real-time + for chunk in stream: + if chunk.choices[0].delta.content is not None: + print(chunk.choices[0].delta.content, end="") + + def get_memories(self, user_id=None): + """ + Retrieve all memories associated with the given customer ID. + + :param user_id: Optional user ID to filter memories. + :return: List of memories. + """ + return self.memory.get_all(user_id=user_id) + +# Instantiate the CustomerSupportAIAgent +support_agent = CustomerSupportAIAgent() + +# Define a customer ID +customer_id = "jane_doe" + +# Handle a customer query +support_agent.handle_query("I need help with my recent order. It hasn't arrived yet.", user_id=customer_id) +``` + +### Fetching Memories + +You can fetch all the memories at any point in time using the following code: + +```python +memories = support_agent.get_memories(user_id=customer_id) +for m in memories['results']: + print(m['memory']) +``` + +### Key Points + +- **Initialization**: The CustomerSupportAIAgent class is initialized with the necessary memory configuration and OpenAI client setup. +- **Handling Queries**: The handle_query method sends a query to the AI and stores the relevant information in memory. +- **Retrieving Memories**: The get_memories method fetches all stored memories associated with a customer. + +### Conclusion + +As the conversation progresses, Mem0's memory automatically updates based on the interactions, providing a continuously improving personalized support experience. \ No newline at end of file diff --git a/docs/v0x/examples/eliza_os.mdx b/docs/v0x/examples/eliza_os.mdx new file mode 100644 index 000000000..8d0178008 --- /dev/null +++ b/docs/v0x/examples/eliza_os.mdx @@ -0,0 +1,73 @@ +--- +title: Eliza OS Character +--- + +You can create a personalised Eliza OS Character using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started. + +## Overview + +ElizaOS is a powerful AI agent framework for autonomy & personality. It is a collection of tools that help you create a personalised AI agent. + +## Setup +You can start by cloning the eliza-os repository: + +```bash +git clone https://github.com/elizaOS/eliza.git +``` + +Change the directory to the eliza-os repository: + +```bash +cd eliza +``` + +Install the dependencies: + +```bash +pnpm install +``` + +Build the project: + +```bash +pnpm build +``` + +## Setup ENVs + +Create a `.env` file in the root of the project and add the following ( You can use the `.env.example` file as a reference): + +```bash +# Mem0 Configuration +MEM0_API_KEY= # Mem0 API Key ( Get from https://app.mem0.ai/dashboard/api-keys ) +MEM0_USER_ID= # Default: eliza-os-user +MEM0_PROVIDER= # Default: openai +MEM0_PROVIDER_API_KEY= # API Key for the provider (openai, anthropic, etc.) +SMALL_MEM0_MODEL= # Default: gpt-4o-mini +MEDIUM_MEM0_MODEL= # Default: gpt-4o +LARGE_MEM0_MODEL= # Default: gpt-4o +``` + +## Make the default character use Mem0 + +By default, there is a character called `eliza` that uses the `ollama` model. You can make this character use Mem0 by changing the config in the `agent/src/defaultCharacter.ts` file. + +```ts +modelProvider: ModelProviderName.MEM0, +``` + +This will make the character use Mem0 to generate responses. + +## Run the project + +```bash +pnpm start +``` + +## Conclusion + +You have now created a personalised Eliza OS Character using Mem0. You can now start interacting with the character by running the project and talking to the character. + +This is a simple example of how to use Mem0 to create a personalised AI agent. You can use this as a starting point to create your own AI agent. + + diff --git a/docs/v0x/examples/email_processing.mdx b/docs/v0x/examples/email_processing.mdx new file mode 100644 index 000000000..572d18323 --- /dev/null +++ b/docs/v0x/examples/email_processing.mdx @@ -0,0 +1,186 @@ +--- +title: Email Processing with Mem0 +--- + +This guide demonstrates how to build an intelligent email processing system using Mem0's memory capabilities. You'll learn how to store, categorize, retrieve, and analyze emails to create a smart email management solution. + +## Overview + +Email overload is a common challenge for many professionals. By leveraging Mem0's memory capabilities, you can build an intelligent system that: + +- Stores emails as searchable memories +- Categorizes emails automatically +- Retrieves relevant past conversations +- Prioritizes messages based on importance +- Generates summaries and action items + +## Setup + +Before you begin, ensure you have the required dependencies installed: + +```bash +pip install mem0ai openai +``` + +## Implementation + +### Basic Email Memory System + +The following example shows how to create a basic email processing system with Mem0: + +```python +import os +from mem0 import MemoryClient +from email.parser import Parser + +# Configure API keys +os.environ["MEM0_API_KEY"] = "your-mem0-api-key" + +# Initialize Mem0 client +client = MemoryClient() + +class EmailProcessor: + def __init__(self): + """Initialize the Email Processor with Mem0 memory client""" + self.client = client + + def process_email(self, email_content, user_id): + """ + Process an email and store it in Mem0 memory + + Args: + email_content (str): Raw email content + user_id (str): User identifier for memory association + """ + # Parse email + parser = Parser() + email = parser.parsestr(email_content) + + # Extract email details + sender = email['from'] + recipient = email['to'] + subject = email['subject'] + date = email['date'] + body = self._get_email_body(email) + + # Create message object for Mem0 + message = { + "role": "user", + "content": f"Email from {sender}: {subject}\n\n{body}" + } + + # Create metadata for better retrieval + metadata = { + "email_type": "incoming", + "sender": sender, + "recipient": recipient, + "subject": subject, + "date": date + } + + # Store in Mem0 with appropriate categories + response = self.client.add( + messages=[message], + user_id=user_id, + metadata=metadata, + categories=["email", "correspondence"], + version="v2" + ) + + return response + + def _get_email_body(self, email): + """Extract the body content from an email""" + # Simplified extraction - in real-world, handle multipart emails + if email.is_multipart(): + for part in email.walk(): + if part.get_content_type() == "text/plain": + return part.get_payload(decode=True).decode() + else: + return email.get_payload(decode=True).decode() + + def search_emails(self, query, user_id): + """ + Search through stored emails + + Args: + query (str): Search query + user_id (str): User identifier + """ + # Search Mem0 for relevant emails + results = self.client.search( + query=query, + user_id=user_id, + categories=["email"], + output_format="v1.1", + version="v2" + ) + + return results + + def get_email_thread(self, subject, user_id): + """ + Retrieve all emails in a thread based on subject + + Args: + subject (str): Email subject to match + user_id (str): User identifier + """ + filters = { + "AND": [ + {"user_id": user_id}, + {"categories": {"contains": "email"}}, + {"metadata": {"subject": {"contains": subject}}} + ] + } + + thread = self.client.get_all( + version="v2", + filters=filters, + output_format="v1.1" + ) + + return thread + +# Initialize the processor +processor = EmailProcessor() + +# Example raw email +sample_email = """From: alice@example.com +To: bob@example.com +Subject: Meeting Schedule Update +Date: Mon, 15 Jul 2024 14:22:05 -0700 + +Hi Bob, + +I wanted to update you on the schedule for our upcoming project meeting. +We'll be meeting this Thursday at 2pm instead of Friday. + +Could you please prepare your section of the presentation? + +Thanks, +Alice +""" + +# Process and store the email +user_id = "bob@example.com" +processor.process_email(sample_email, user_id) + +# Later, search for emails about meetings +meeting_emails = processor.search_emails("meeting schedule", user_id) +print(f"Found {len(meeting_emails['results'])} relevant emails") +``` + +## Key Features and Benefits + +- **Long-term Email Memory**: Store and retrieve email conversations across long periods +- **Semantic Search**: Find relevant emails even if they don't contain exact keywords +- **Intelligent Categorization**: Automatically sort emails into meaningful categories +- **Action Item Extraction**: Identify and track tasks mentioned in emails +- **Priority Management**: Focus on important emails based on AI-determined priority +- **Context Awareness**: Maintain thread context for more relevant interactions + +## Conclusion + +By combining Mem0's memory capabilities with email processing, you can create intelligent email management systems that help users organize, prioritize, and act on their inbox effectively. The advanced capabilities like automatic categorization, action item extraction, and priority management can significantly reduce the time spent on email management, allowing users to focus on more important tasks. + diff --git a/docs/v0x/examples/llama-index-mem0.mdx b/docs/v0x/examples/llama-index-mem0.mdx new file mode 100644 index 000000000..d7d57715b --- /dev/null +++ b/docs/v0x/examples/llama-index-mem0.mdx @@ -0,0 +1,173 @@ +--- +title: LlamaIndex ReAct Agent +--- + +Create a ReAct Agent with LlamaIndex which uses Mem0 as the memory store. + +### Overview +A ReAct agent combines reasoning and action capabilities, making it versatile for tasks requiring both thought processes (reasoning) and interaction with tools or APIs (acting). Mem0 as memory enhances these capabilities by allowing the agent to store and retrieve contextual information from past interactions. + +### Setup +```bash +pip install llama-index-core llama-index-memory-mem0 +``` + +Initialize the LLM. +```python +import os +from llama_index.llms.openai import OpenAI + +os.environ["OPENAI_API_KEY"] = "" +llm = OpenAI(model="gpt-4o") +``` + +Initialize the Mem0 client. You can find your API key [here](https://app.mem0.ai/dashboard/api-keys). Read about Mem0 [Open Source](https://docs.mem0.ai/open-source/overview). +```python +os.environ["MEM0_API_KEY"] = "" + +from llama_index.memory.mem0 import Mem0Memory + +context = {"user_id": "david"} +memory_from_client = Mem0Memory.from_client( + context=context, + api_key=os.environ["MEM0_API_KEY"], + search_msg_limit=4, # optional, default is 5 +) +``` + +Create the tools. These tools will be used by the agent to perform actions. +```python +from llama_index.core.tools import FunctionTool + +def call_fn(name: str): + """Call the provided name. + Args: + name: str (Name of the person) + """ + return f"Calling... {name}" + +def email_fn(name: str): + """Email the provided name. + Args: + name: str (Name of the person) + """ + return f"Emailing... {name}" + +def order_food(name: str, dish: str): + """Order food for the provided name. + Args: + name: str (Name of the person) + dish: str (Name of the dish) + """ + return f"Ordering {dish} for {name}" + +call_tool = FunctionTool.from_defaults(fn=call_fn) +email_tool = FunctionTool.from_defaults(fn=email_fn) +order_food_tool = FunctionTool.from_defaults(fn=order_food) +``` + +Initialize the agent with tools and memory. +```python +from llama_index.core.agent import FunctionCallingAgent + +agent = FunctionCallingAgent.from_tools( + [call_tool, email_tool, order_food_tool], + llm=llm, + memory=memory_from_client, # or memory_from_config + verbose=True, +) +``` + +Start the chat. + The agent will use the Mem0 to store the relevant memories from the chat. + +Input +```python +response = agent.chat("Hi, My name is David") +print(response) +``` +Output +```text +> Running step bf44a75a-a920-4cf3-944e-b6e6b5695043. Step input: Hi, My name is David +Added user message to memory: Hi, My name is David +=== LLM Response === +Hello, David! How can I assist you today? +``` + +Input +```python +response = agent.chat("I love to eat pizza on weekends") +print(response) +``` +Output +```text +> Running step 845783b0-b85b-487c-baee-8460ebe8b38d. Step input: I love to eat pizza on weekends +Added user message to memory: I love to eat pizza on weekends +=== LLM Response === +Pizza is a great choice for the weekend! If you'd like, I can help you order some. Just let me know what kind of pizza you prefer! +``` +Input +```python +response = agent.chat("My preferred way of communication is email") +print(response) +``` +Output +```text +> Running step 345842f0-f8a0-42ea-a1b7-612265d72a92. Step input: My preferred way of communication is email +Added user message to memory: My preferred way of communication is email +=== LLM Response === +Got it! If you need any assistance or have any requests, feel free to let me know, and I can communicate with you via email. +``` + +### Using the agent WITHOUT memory +Input +```python +agent = FunctionCallingAgent.from_tools( + [call_tool, email_tool, order_food_tool], + # memory is not provided + llm=llm, + verbose=True, +) +response = agent.chat("I am feeling hungry, order me something and send me the bill") +print(response) +``` +Output +```text +> Running step e89eb75d-75e1-4dea-a8c8-5c3d4b77882d. Step input: I am feeling hungry, order me something and send me the bill +Added user message to memory: I am feeling hungry, order me something and send me the bill +=== LLM Response === +Please let me know your name and the dish you'd like to order, and I'll take care of it for you! +``` + The agent is not able to remember the past preferences that user shared in previous chats. + +### Using the agent WITH memory +Input +```python +agent = FunctionCallingAgent.from_tools( + [call_tool, email_tool, order_food_tool], + llm=llm, + # memory is provided + memory=memory_from_client, # or memory_from_config + verbose=True, +) +response = agent.chat("I am feeling hungry, order me something and send me the bill") +print(response) +``` + +Output +```text +> Running step 5e473db9-3973-4cb1-a5fd-860be0ab0006. Step input: I am feeling hungry, order me something and send me the bill +Added user message to memory: I am feeling hungry, order me something and send me the bill +=== Calling Function === +Calling function: order_food with args: {"name": "David", "dish": "pizza"} +=== Function Output === +Ordering pizza for David +=== Calling Function === +Calling function: email_fn with args: {"name": "David"} +=== Function Output === +Emailing... David +> Running step 38080544-6b37-4bb2-aab2-7670100d926e. Step input: None +=== LLM Response === +I've ordered a pizza for you, and the bill has been sent to your email. Enjoy your meal! If there's anything else you need, feel free to let me know. +``` + The agent is able to remember the past preferences that user shared and use them to perform actions. diff --git a/docs/v0x/examples/llamaindex-multiagent-learning-system.mdx b/docs/v0x/examples/llamaindex-multiagent-learning-system.mdx new file mode 100644 index 000000000..149a503a6 --- /dev/null +++ b/docs/v0x/examples/llamaindex-multiagent-learning-system.mdx @@ -0,0 +1,360 @@ +--- +title: LlamaIndex Multi-Agent Learning System +--- + + + +Build an intelligent multi-agent learning system that uses Mem0 to maintain persistent memory across multiple specialized agents. This example demonstrates how to create a tutoring system where different agents collaborate while sharing a unified memory layer. + +## Overview + +This example showcases a **Multi-Agent Personal Learning System** that combines: +- **LlamaIndex AgentWorkflow** for multi-agent orchestration +- **Mem0** for persistent, shared memory across agents +- **Multi-agents** that collaborate on teaching tasks + +The system consists of two agents: +- **TutorAgent**: Primary instructor for explanations and concept teaching +- **PracticeAgent**: Generates exercises and tracks learning progress + +Both agents share the same memory context, enabling seamless collaboration and continuous learning from student interactions. + +## Key Features + +- **Persistent Memory**: Agents remember previous interactions across sessions +- **Multi-Agent Collaboration**: Agents can hand off tasks to each other +- **Personalized Learning**: Adapts to individual student needs and learning styles +- **Progress Tracking**: Monitors learning patterns and skill development +- **Memory-Driven Teaching**: References past struggles and successes + +## Prerequisites + +Install the required packages: + +```bash +pip install llama-index-core llama-index-memory-mem0 openai python-dotenv +``` + +Set up your environment variables: +- `MEM0_API_KEY`: Your Mem0 Platform API key +- `OPENAI_API_KEY`: Your OpenAI API key + +You can obtain your Mem0 Platform API key from the [Mem0 Platform](https://app.mem0.ai). + +## Complete Implementation + +```python +""" +Multi-Agent Personal Learning System: Mem0 + LlamaIndex AgentWorkflow Example + +INSTALLATIONS: +!pip install llama-index-core llama-index-memory-mem0 openai + +You need MEM0_API_KEY and OPENAI_API_KEY to run the example. +""" + +import asyncio +from datetime import datetime +from dotenv import load_dotenv + +# LlamaIndex imports +from llama_index.core.agent.workflow import AgentWorkflow, FunctionAgent +from llama_index.llms.openai import OpenAI +from llama_index.core.tools import FunctionTool + +# Memory integration +from llama_index.memory.mem0 import Mem0Memory + +import warnings +warnings.filterwarnings("ignore", category=DeprecationWarning) + +load_dotenv() + + +class MultiAgentLearningSystem: + """ + Multi-Agent Architecture: + - TutorAgent: Main teaching and explanations + - PracticeAgent: Exercises and skill reinforcement + - Shared Memory: Both agents learn from student interactions + """ + + def __init__(self, student_id: str): + self.student_id = student_id + self.llm = OpenAI(model="gpt-4o", temperature=0.2) + + # Memory context for this student + self.memory_context = {"user_id": student_id, "app": "learning_assistant"} + self.memory = Mem0Memory.from_client( + context=self.memory_context + ) + + self._setup_agents() + + def _setup_agents(self): + """Setup two agents that work together and share memory""" + + # TOOLS + async def assess_understanding(topic: str, student_response: str) -> str: + """Assess student's understanding of a topic and save insights""" + # Simulate assessment logic + if "confused" in student_response.lower() or "don't understand" in student_response.lower(): + assessment = f"STRUGGLING with {topic}: {student_response}" + insight = f"Student needs more help with {topic}. Prefers step-by-step explanations." + elif "makes sense" in student_response.lower() or "got it" in student_response.lower(): + assessment = f"UNDERSTANDS {topic}: {student_response}" + insight = f"Student grasped {topic} quickly. Can move to advanced concepts." + else: + assessment = f"PARTIAL understanding of {topic}: {student_response}" + insight = f"Student has basic understanding of {topic}. Needs reinforcement." + + return f"Assessment: {assessment}\nInsight saved: {insight}" + + async def track_progress(topic: str, success_rate: str) -> str: + """Track learning progress and identify patterns""" + progress_note = f"Progress on {topic}: {success_rate} - {datetime.now().strftime('%Y-%m-%d')}" + return f"Progress tracked: {progress_note}" + + # Convert to FunctionTools + tools = [ + FunctionTool.from_defaults(async_fn=assess_understanding), + FunctionTool.from_defaults(async_fn=track_progress) + ] + + # AGENTS + # Tutor Agent - Main teaching and explanation + self.tutor_agent = FunctionAgent( + name="TutorAgent", + description="Primary instructor that explains concepts and adapts to student needs", + system_prompt=""" + You are a patient, adaptive programming tutor. Your key strength is REMEMBERING and BUILDING on previous interactions. + + Key Behaviors: + 1. Always check what the student has learned before (use memory context) + 2. Adapt explanations based on their preferred learning style + 3. Reference previous struggles or successes + 4. Build progressively on past lessons + 5. Use assess_understanding to evaluate responses and save insights + + MEMORY-DRIVEN TEACHING: + - "Last time you struggled with X, so let's approach Y differently..." + - "Since you prefer visual examples, here's a diagram..." + - "Building on the functions we covered yesterday..." + + When student shows understanding, hand off to PracticeAgent for exercises. + """, + tools=tools, + llm=self.llm, + can_handoff_to=["PracticeAgent"] + ) + + # Practice Agent - Exercises and reinforcement + self.practice_agent = FunctionAgent( + name="PracticeAgent", + description="Creates practice exercises and tracks progress based on student's learning history", + system_prompt=""" + You create personalized practice exercises based on the student's learning history and current level. + + Key Behaviors: + 1. Generate problems that match their skill level (from memory) + 2. Focus on areas they've struggled with previously + 3. Gradually increase difficulty based on their progress + 4. Use track_progress to record their performance + 5. Provide encouraging feedback that references their growth + + MEMORY-DRIVEN PRACTICE: + - "Let's practice loops again since you wanted more examples..." + - "Here's a harder version of the problem you solved yesterday..." + - "You've improved a lot in functions, ready for the next level?" + + After practice, can hand back to TutorAgent for concept review if needed. + """, + tools=tools, + llm=self.llm, + can_handoff_to=["TutorAgent"] + ) + + # Create the multi-agent workflow + self.workflow = AgentWorkflow( + agents=[self.tutor_agent, self.practice_agent], + root_agent=self.tutor_agent.name, + initial_state={ + "current_topic": "", + "student_level": "beginner", + "learning_style": "unknown", + "session_goals": [] + } + ) + + async def start_learning_session(self, topic: str, student_message: str = "") -> str: + """ + Start a learning session with multi-agent memory-aware teaching + """ + + if student_message: + request = f"I want to learn about {topic}. {student_message}" + else: + request = f"I want to learn about {topic}." + + # The magic happens here - multi-agent memory is automatically shared! + response = await self.workflow.run( + user_msg=request, + memory=self.memory + ) + + return str(response) + + async def get_learning_history(self) -> str: + """Show what the system remembers about this student""" + try: + # Search memory for learning patterns + memories = self.memory.search( + user_id=self.student_id, + query="learning machine learning" + ) + + if memories and memories.get('results'): + history = "\n".join(f"- {m['memory']}" for m in memories['results']) + return history + else: + return "No learning history found yet. Let's start building your profile!" + + except Exception as e: + return f"Memory retrieval error: {str(e)}" + + +async def run_learning_agent(): + + learning_system = MultiAgentLearningSystem(student_id="Alexander") + + # First session + print("Session 1:") + response = await learning_system.start_learning_session( + "Vision Language Models", + "I'm new to machine learning but I have good hold on Python and have 4 years of work experience.") + print(response) + + # Second session - multi-agent memory will remember the first + print("\nSession 2:") + response2 = await learning_system.start_learning_session( + "Machine Learning", "what all did I cover so far?") + print(response2) + + # Show what the multi-agent system remembers + print("\nLearning History:") + history = await learning_system.get_learning_history() + print(history) + + +if __name__ == "__main__": + """Run the example""" + print("Multi-agent Learning System powered by LlamaIndex and Mem0") + + async def main(): + await run_learning_agent() + + asyncio.run(main()) +``` + +## How It Works + +### 1. Memory Context Setup + +```python +# Memory context for this student +self.memory_context = {"user_id": student_id, "app": "learning_assistant"} +self.memory = Mem0Memory.from_client(context=self.memory_context) +``` + +The memory context identifies the specific student and application, ensuring memory isolation and proper retrieval. + +### 2. Agent Collaboration + +```python +# Agents can hand off to each other +can_handoff_to=["PracticeAgent"] # TutorAgent can hand off to PracticeAgent +can_handoff_to=["TutorAgent"] # PracticeAgent can hand off back +``` + +Agents collaborate seamlessly, with the TutorAgent handling explanations and the PracticeAgent managing exercises. + +### 3. Shared Memory + +```python +# Both agents share the same memory instance +response = await self.workflow.run( + user_msg=request, + memory=self.memory # Shared across all agents +) +``` + +All agents in the workflow share the same memory context, enabling true collaborative learning. + +### 4. Memory-Driven Interactions + +The system prompts guide agents to: +- Reference previous learning sessions +- Adapt to discovered learning styles +- Build progressively on past lessons +- Track and respond to learning patterns + +## Running the Example + +```python +# Initialize the learning system +learning_system = MultiAgentLearningSystem(student_id="Alexander") + +# Start a learning session +response = await learning_system.start_learning_session( + "Vision Language Models", + "I'm new to machine learning but I have good hold on Python and have 4 years of work experience." +) + +# Continue learning in a new session (memory persists) +response2 = await learning_system.start_learning_session( + "Machine Learning", + "what all did I cover so far?" +) + +# Check learning history +history = await learning_system.get_learning_history() +``` + +## Expected Output + +The system will demonstrate memory-aware interactions: + +``` +Session 1: +I understand you want to learn about Vision Language Models and you mentioned you're new to machine learning but have a strong Python background with 4 years of experience. That's a great foundation to build on! + +Let me start with an explanation tailored to your programming background... +[Agent provides explanation and may hand off to PracticeAgent for exercises] + +Session 2: +Based on our previous session, I remember we covered Vision Language Models and I noted that you have a strong Python background with 4 years of experience. You mentioned being new to machine learning, so we started with foundational concepts... +[Agent references previous session and builds upon it] +``` + +## Key Benefits + +1. **Persistent Learning**: Agents remember across sessions, creating continuity +2. **Collaborative Teaching**: Multiple specialized agents work together seamlessly +3. **Personalized Adaptation**: System learns and adapts to individual learning styles +4. **Scalable Architecture**: Easy to add more specialized agents +5. **Memory Efficiency**: Shared memory prevents duplication and ensures consistency + + +## Best Practices + +1. **Clear Agent Roles**: Define specific responsibilities for each agent +2. **Memory Context**: Use descriptive context for memory isolation +3. **Handoff Strategy**: Design clear handoff criteria between agents +5. **Memory Hygiene**: Regularly review and clean memory for optimal performance + +## Help & Resources + +- [LlamaIndex Agent Workflows](https://docs.llamaindex.ai/en/stable/use_cases/agents/) +- [Mem0 Platform](https://app.mem0.ai/) + + \ No newline at end of file diff --git a/docs/v0x/examples/mem0-agentic-tool.mdx b/docs/v0x/examples/mem0-agentic-tool.mdx new file mode 100644 index 000000000..a616876e4 --- /dev/null +++ b/docs/v0x/examples/mem0-agentic-tool.mdx @@ -0,0 +1,227 @@ +--- +title: Mem0 as an Agentic Tool +--- + + +Integrate Mem0's memory capabilities with OpenAI's Agents SDK to create AI agents with persistent memory. +You can create agents that remember past conversations and use that context to provide better responses. + +## Installation + +First, install the required packages: +```bash +pip install mem0ai pydantic openai-agents +``` + +You'll also need a custom agents framework for this implementation. + +## Setting Up Environment Variables + +Store your Mem0 API key as an environment variable: + +```bash +export MEM0_API_KEY="your_mem0_api_key" +``` + +Or in your Python script: + +```python +import os +os.environ["MEM0_API_KEY"] = "your_mem0_api_key" +``` + +## Code Structure + +The integration consists of three main components: + +1. **Context Manager**: Defines user context for memory operations +2. **Memory Tools**: Functions to add, search, and retrieve memories +3. **Memory Agent**: An agent configured to use these memory tools + +## Step-by-Step Implementation + +### 1. Import Dependencies + +```python +from __future__ import annotations +import os +import asyncio +from pydantic import BaseModel +try: + from mem0 import AsyncMemoryClient +except ImportError: + raise ImportError("mem0 is not installed. Please install it using 'pip install mem0ai'.") +from agents import ( + Agent, + ItemHelpers, + MessageOutputItem, + RunContextWrapper, + Runner, + ToolCallItem, + ToolCallOutputItem, + TResponseInputItem, + function_tool, +) +``` + +### 2. Define Memory Context + +```python +class Mem0Context(BaseModel): + user_id: str | None = None +``` + +### 3. Initialize the Mem0 Client + +```python +client = AsyncMemoryClient(api_key=os.getenv("MEM0_API_KEY")) +``` + +### 4. Create Memory Tools + +#### Add to Memory + +```python +@function_tool +async def add_to_memory( + context: RunContextWrapper[Mem0Context], + content: str, +) -> str: + """ + Add a message to Mem0 + Args: + content: The content to store in memory. + """ + messages = [{"role": "user", "content": content}] + user_id = context.context.user_id or "default_user" + await client.add(messages, user_id=user_id) + return f"Stored message: {content}" +``` + +#### Search Memory + +```python +@function_tool +async def search_memory( + context: RunContextWrapper[Mem0Context], + query: str, +) -> str: + """ + Search for memories in Mem0 + Args: + query: The search query. + """ + user_id = context.context.user_id or "default_user" + memories = await client.search(query, user_id=user_id, output_format="v1.1") + results = '\n'.join([result["memory"] for result in memories["results"]]) + return str(results) +``` + +#### Get All Memories + +```python +@function_tool +async def get_all_memory( + context: RunContextWrapper[Mem0Context], +) -> str: + """Retrieve all memories from Mem0""" + user_id = context.context.user_id or "default_user" + memories = await client.get_all(user_id=user_id, output_format="v1.1") + results = '\n'.join([result["memory"] for result in memories["results"]]) + return str(results) +``` + +### 5. Configure the Memory Agent + +```python +memory_agent = Agent[Mem0Context]( + name="Memory Assistant", + instructions="""You are a helpful assistant with memory capabilities. You can: + 1. Store new information using add_to_memory + 2. Search existing information using search_memory + 3. Retrieve all stored information using get_all_memory + When users ask questions: + - If they want to store information, use add_to_memory + - If they're searching for specific information, use search_memory + - If they want to see everything stored, use get_all_memory""", + tools=[add_to_memory, search_memory, get_all_memory], +) +``` + +### 6. Implement the Main Runtime Loop + +```python +async def main(): + current_agent: Agent[Mem0Context] = memory_agent + input_items: list[TResponseInputItem] = [] + context = Mem0Context() + while True: + user_input = input("Enter your message (or 'quit' to exit): ") + if user_input.lower() == 'quit': + break + input_items.append({"content": user_input, "role": "user"}) + result = await Runner.run(current_agent, input_items, context=context) + for new_item in result.new_items: + agent_name = new_item.agent.name + if isinstance(new_item, MessageOutputItem): + print(f"{agent_name}: {ItemHelpers.text_message_output(new_item)}") + elif isinstance(new_item, ToolCallItem): + print(f"{agent_name}: Calling a tool") + elif isinstance(new_item, ToolCallOutputItem): + print(f"{agent_name}: Tool call output: {new_item.output}") + else: + print(f"{agent_name}: Skipping item: {new_item.__class__.__name__}") + input_items = result.to_input_list() + +if __name__ == "__main__": + asyncio.run(main()) +``` + +## Usage Examples + +### Storing Information + +``` +User: Remember that my favorite color is blue +Agent: Calling a tool +Agent: Tool call output: Stored message: my favorite color is blue +Agent: I've stored that your favorite color is blue in my memory. I'll remember that for future conversations. +``` + +### Searching Memory + +``` +User: What's my favorite color? +Agent: Calling a tool +Agent: Tool call output: my favorite color is blue +Agent: Your favorite color is blue, based on what you've told me earlier. +``` + +### Retrieving All Memories + +``` +User: What do you know about me? +Agent: Calling a tool +Agent: Tool call output: favorite color is blue +my birthday is on March 15 +Agent: Based on our previous conversations, I know that: +1. Your favorite color is blue +2. Your birthday is on March 15 +``` + +## Advanced Configuration + +### Custom User IDs + +You can specify different user IDs to maintain separate memory stores for multiple users: + +```python +context = Mem0Context(user_id="user123") +``` + + +## Resources + +- [Mem0 Documentation](https://docs.mem0.ai) +- [Mem0 Dashboard](https://app.mem0.ai/dashboard) +- [API Reference](https://docs.mem0.ai/api-reference) diff --git a/docs/v0x/examples/mem0-demo.mdx b/docs/v0x/examples/mem0-demo.mdx new file mode 100644 index 000000000..5b129f6f4 --- /dev/null +++ b/docs/v0x/examples/mem0-demo.mdx @@ -0,0 +1,68 @@ +--- +title: Mem0 Demo +--- + +You can create a personalized AI Companion using Mem0. This guide will walk you through the necessary steps and provide the complete setup instructions to get you started. + + + +You can try the [Mem0 Demo](https://mem0-4vmi.vercel.app) live here. + +## Overview + +The Personalized AI Companion leverages Mem0 to retain information across interactions, enabling a tailored learning experience. It creates memories for each user interaction and integrates with OpenAI's GPT models to provide detailed and context-aware responses to user queries. + +## Setup + +Before you begin, follow these steps to set up the demo application: + +1. Clone the Mem0 repository: + ```bash + git clone https://github.com/mem0ai/mem0.git + ``` + +2. Navigate to the demo application folder: + ```bash + cd mem0/examples/mem0-demo + ``` + +3. Install dependencies: + ```bash + pnpm install + ``` + +4. Set up environment variables by creating a `.env` file in the project root with the following content: + ```bash + OPENAI_API_KEY=your_openai_api_key + MEM0_API_KEY=your_mem0_api_key + ``` + You can obtain your `MEM0_API_KEY` by signing up at [Mem0 API Dashboard](https://app.mem0.ai/dashboard/api-keys). + +5. Start the development server: + ```bash + pnpm run dev + ``` + +## Enhancing the Next.js Application + +Once the demo is running, you can customize and enhance the Next.js application by modifying the components in the `mem0-demo` folder. Consider: +- Adding new memory features to improve contextual retention. +- Customizing the UI to better suit your application needs. +- Integrating additional APIs or third-party services to extend functionality. + +## Full Code + +You can find the complete source code for this demo on GitHub: +[Mem0 Demo GitHub](https://github.com/mem0ai/mem0/tree/main/examples/mem0-demo) + +## Conclusion + +This setup demonstrates how to build an AI Companion that maintains memory across interactions using Mem0. The system continuously adapts to user interactions, making future responses more relevant and personalized. Experiment with the application and enhance it further to suit your use case! + diff --git a/docs/v0x/examples/mem0-google-adk-healthcare-assistant.mdx b/docs/v0x/examples/mem0-google-adk-healthcare-assistant.mdx new file mode 100644 index 000000000..c6b40ac1b --- /dev/null +++ b/docs/v0x/examples/mem0-google-adk-healthcare-assistant.mdx @@ -0,0 +1,293 @@ +--- +title: 'Healthcare Assistant with Mem0 and Google ADK' +description: 'Build a personalized healthcare agent that remembers patient information across conversations using Mem0 and Google ADK' +--- + + +# Healthcare Assistant with Memory + +This example demonstrates how to build a healthcare assistant that remembers patient information across conversations using Google ADK and Mem0. + +## Overview + +The Healthcare Assistant helps patients by: +- Remembering their medical history and symptoms +- Providing general health information +- Scheduling appointment reminders +- Maintaining a personalized experience across conversations + +By integrating Mem0's memory layer with Google ADK, the assistant maintains context about the patient without requiring them to repeat information. + +## Setup + +Before you begin, make sure you have: + +Installed Google ADK and Mem0 SDK: +```bash +pip install google-adk mem0ai python-dotenv +``` + +## Code Breakdown + +Let's get started and understand the different components required in building a healthcare assistant powered by memory + +```python +# Import dependencies +import os +import asyncio +from google.adk.agents import Agent +from google.adk.runners import Runner +from google.adk.sessions import InMemorySessionService +from google.genai import types +from mem0 import MemoryClient +from dotenv import load_dotenv + +load_dotenv() + +# Set up environment variables +# os.environ["GOOGLE_API_KEY"] = "your-google-api-key" +# os.environ["MEM0_API_KEY"] = "your-mem0-api-key" + +# Define a global user ID for simplicity +USER_ID = "Alex" + +# Initialize Mem0 client +mem0 = MemoryClient() +``` + +## Define Memory Tools + +First, we'll create tools that allow our agent to store and retrieve information using Mem0: + +```python +def save_patient_info(information: str) -> dict: + """Saves important patient information to memory.""" + + # Store in Mem0 + response = mem0_client.add( + [{"role": "user", "content": information}], + user_id=USER_ID, + run_id="healthcare_session", + metadata={"type": "patient_information"} + ) + + +def retrieve_patient_info(query: str) -> dict: + """Retrieves relevant patient information from memory.""" + + # Search Mem0 + results = mem0_client.search( + query, + user_id=USER_ID, + limit=5, + threshold=0.7, # Higher threshold for more relevant results + output_format="v1.1" + ) + + # Format and return the results + if results and len(results) > 0: + memories = [memory["memory"] for memory in results.get('results', [])] + return { + "status": "success", + "memories": memories, + "count": len(memories) + } + else: + return { + "status": "no_results", + "memories": [], + "count": 0 + } +``` + +## Define Healthcare Tools + +Next, we'll add tools specific to healthcare assistance: + +```python +def schedule_appointment(date: str, time: str, reason: str) -> dict: + """Schedules a doctor's appointment.""" + # In a real app, this would connect to a scheduling system + appointment_id = f"APT-{hash(date + time) % 10000}" + + return { + "status": "success", + "appointment_id": appointment_id, + "confirmation": f"Appointment scheduled for {date} at {time} for {reason}", + "message": "Please arrive 15 minutes early to complete paperwork." + } +``` + +## Create the Healthcare Assistant Agent + +Now we'll create our main agent with all the tools: + +```python +# Create the agent +healthcare_agent = Agent( + name="healthcare_assistant", + model="gemini-1.5-flash", # Using Gemini for healthcare assistant + description="Healthcare assistant that helps patients with health information and appointment scheduling.", + instruction="""You are a helpful Healthcare Assistant with memory capabilities. + +Your primary responsibilities are to: +1. Remember patient information using the 'save_patient_info' tool when they share symptoms, conditions, or preferences. +2. Retrieve past patient information using the 'retrieve_patient_info' tool when relevant to the current conversation. +3. Help schedule appointments using the 'schedule_appointment' tool. + +IMPORTANT GUIDELINES: +- Always be empathetic, professional, and helpful. +- Save important patient information like symptoms, conditions, allergies, and preferences. +- Check if you have relevant patient information before asking for details they may have shared previously. +- Make it clear you are not a doctor and cannot provide medical diagnosis or treatment. +- For serious symptoms, always recommend consulting a healthcare professional. +- Keep all patient information confidential. +""", + tools=[save_patient_info, retrieve_patient_info, schedule_appointment] +) +``` + +## Set Up Session and Runner + +```python +# Set up Session Service and Runner +session_service = InMemorySessionService() + +# Define constants for the conversation +APP_NAME = "healthcare_assistant_app" +USER_ID = "Alex" +SESSION_ID = "session_001" + +# Create a session +session = session_service.create_session( + app_name=APP_NAME, + user_id=USER_ID, + session_id=SESSION_ID +) + +# Create the runner +runner = Runner( + agent=healthcare_agent, + app_name=APP_NAME, + session_service=session_service +) +``` + +## Interact with the Healthcare Assistant + +```python +# Function to interact with the agent +async def call_agent_async(query, runner, user_id, session_id): + """Sends a query to the agent and returns the final response.""" + print(f"\n>>> Patient: {query}") + + # Format the user's message + content = types.Content( + role='user', + parts=[types.Part(text=query)] + ) + + # Set user_id for tools to access + save_patient_info.user_id = user_id + retrieve_patient_info.user_id = user_id + + # Run the agent + async for event in runner.run_async( + user_id=user_id, + session_id=session_id, + new_message=content + ): + if event.is_final_response(): + if event.content and event.content.parts: + response = event.content.parts[0].text + print(f"<<< Assistant: {response}") + return response + + return "No response received." + +# Example conversation flow +async def run_conversation(): + # First interaction - patient introduces themselves with key information + await call_agent_async( + "Hi, I'm Alex. I've been having headaches for the past week, and I have a penicillin allergy.", + runner=runner, + user_id=USER_ID, + session_id=SESSION_ID + ) + + # Request for health information + await call_agent_async( + "Can you tell me more about what might be causing my headaches?", + runner=runner, + user_id=USER_ID, + session_id=SESSION_ID + ) + + # Schedule an appointment + await call_agent_async( + "I think I should see a doctor. Can you help me schedule an appointment for next Monday at 2pm?", + runner=runner, + user_id=USER_ID, + session_id=SESSION_ID + ) + + # Test memory - should remember patient name, symptoms, and allergy + await call_agent_async( + "What medications should I avoid for my headaches?", + runner=runner, + user_id=USER_ID, + session_id=SESSION_ID + ) + +# Run the conversation example +if __name__ == "__main__": + asyncio.run(run_conversation()) +``` + +## How It Works + +This healthcare assistant demonstrates several key capabilities: + +1. **Memory Storage**: When Alex mentions her headaches and penicillin allergy, the agent stores this information in Mem0 using the `save_patient_info` tool. + +2. **Contextual Retrieval**: When Alex asks about headache causes, the agent uses the `retrieve_patient_info` tool to recall her specific situation. + +3. **Memory Application**: When discussing medications, the agent remembers Alex's penicillin allergy without her needing to repeat it, providing safer and more personalized advice. + +4. **Conversation Continuity**: The agent maintains context across the entire conversation session, creating a more natural and efficient interaction. + +## Key Implementation Details + +### User ID Management + +Instead of passing the user ID as a parameter to the memory tools (which would require modifying the ADK's tool calling system), we attach it directly to the function object: + +```python +# Set user_id for tools to access +save_patient_info.user_id = user_id +retrieve_patient_info.user_id = user_id +``` + +Inside the tool functions, we retrieve this attribute: + +```python +# Get user_id from session state or use default +user_id = getattr(save_patient_info, 'user_id', 'default_user') +``` + +This approach allows our tools to maintain user context without complicating their parameter signatures. + +### Mem0 Integration + +The integration with Mem0 happens through two primary functions: + +1. `mem0_client.add()` - Stores new information with appropriate metadata +2. `mem0_client.search()` - Retrieves relevant memories using semantic search + +The `threshold` parameter in the search function ensures that only highly relevant memories are returned. + +## Conclusion + +This example demonstrates how to build a healthcare assistant with persistent memory using Google ADK and Mem0. The integration allows for a more personalized patient experience by maintaining context across conversation turns, which is particularly valuable in healthcare scenarios where continuity of information is crucial. + +By storing and retrieving patient information intelligently, the assistant provides more relevant responses without requiring the patient to repeat their medical history, symptoms, or preferences. diff --git a/docs/v0x/examples/mem0-mastra.mdx b/docs/v0x/examples/mem0-mastra.mdx new file mode 100644 index 000000000..8c8f58650 --- /dev/null +++ b/docs/v0x/examples/mem0-mastra.mdx @@ -0,0 +1,126 @@ +--- +title: Mem0 with Mastra +--- + +In this example you'll learn how to use the Mem0 to add long-term memory capabilities to [Mastra's agent](https://mastra.ai/) via tool-use. +This memory integration can work alongside Mastra's [agent memory features](https://mastra.ai/docs/agents/01-agent-memory). + +You can find the complete example code in the [Mastra repository](https://github.com/mastra-ai/mastra/tree/main/examples/memory-with-mem0). + +## Overview + +This guide will show you how to integrate Mem0 with Mastra to add long-term memory capabilities to your agents. We'll create tools that allow agents to save and retrieve memories using Mem0's API. + +### Installation + +1. **Install the Integration Package** + +To install the Mem0 integration, run: + +```bash +npm install @mastra/mem0 +``` + +2. **Add the Integration to Your Project** + +Create a new file for your integrations and import the integration: + +```typescript integrations/index.ts +import { Mem0Integration } from "@mastra/mem0"; + +export const mem0 = new Mem0Integration({ + config: { + apiKey: process.env.MEM0_API_KEY!, + userId: "alice", + }, +}); +``` + +3. **Use the Integration in Tools or Workflows** + +You can now use the integration when defining tools for your agents or in workflows. + +```typescript tools/index.ts +import { createTool } from "@mastra/core"; +import { z } from "zod"; +import { mem0 } from "../integrations"; + +export const mem0RememberTool = createTool({ + id: "Mem0-remember", + description: + "Remember your agent memories that you've previously saved using the Mem0-memorize tool.", + inputSchema: z.object({ + question: z + .string() + .describe("Question used to look up the answer in saved memories."), + }), + outputSchema: z.object({ + answer: z.string().describe("Remembered answer"), + }), + execute: async ({ context }) => { + console.log(`Searching memory "${context.question}"`); + const memory = await mem0.searchMemory(context.question); + console.log(`\nFound memory "${memory}"\n`); + + return { + answer: memory, + }; + }, +}); + +export const mem0MemorizeTool = createTool({ + id: "Mem0-memorize", + description: + "Save information to mem0 so you can remember it later using the Mem0-remember tool.", + inputSchema: z.object({ + statement: z.string().describe("A statement to save into memory"), + }), + execute: async ({ context }) => { + console.log(`\nCreating memory "${context.statement}"\n`); + // to reduce latency memories can be saved async without blocking tool execution + void mem0.createMemory(context.statement).then(() => { + console.log(`\nMemory "${context.statement}" saved.\n`); + }); + return { success: true }; + }, +}); +``` + +4. **Create a new agent** + +```typescript agents/index.ts +import { openai } from '@ai-sdk/openai'; +import { Agent } from '@mastra/core/agent'; +import { mem0MemorizeTool, mem0RememberTool } from '../tools'; + +export const mem0Agent = new Agent({ + name: 'Mem0 Agent', + instructions: ` + You are a helpful assistant that has the ability to memorize and remember facts using Mem0. + `, + model: openai('gpt-4o'), + tools: { mem0RememberTool, mem0MemorizeTool }, +}); +``` + +5. **Run the agent** + +```typescript index.ts +import { Mastra } from '@mastra/core/mastra'; +import { createLogger } from '@mastra/core/logger'; + +import { mem0Agent } from './agents'; + +export const mastra = new Mastra({ + agents: { mem0Agent }, + logger: createLogger({ + name: 'Mastra', + level: 'error', + }), +}); +``` + +In the example above: +- We import the `@mastra/mem0` integration. +- We define two tools that uses the Mem0 API client to create new memories and recall previously saved memories. +- The tool accepts `question` as an input and returns the memory as a string. \ No newline at end of file diff --git a/docs/v0x/examples/mem0-openai-voice-demo.mdx b/docs/v0x/examples/mem0-openai-voice-demo.mdx new file mode 100644 index 000000000..42013d45a --- /dev/null +++ b/docs/v0x/examples/mem0-openai-voice-demo.mdx @@ -0,0 +1,538 @@ +--- +title: 'Mem0 with OpenAI Agents SDK for Voice' +description: 'Integrate memory capabilities into your voice agents using Mem0 and OpenAI Agents SDK' +--- + +# Building Voice Agents with Memory using Mem0 and OpenAI Agents SDK + +This guide demonstrates how to combine OpenAI's Agents SDK for voice applications with Mem0's memory capabilities to create a voice assistant that remembers user preferences and past interactions. + +## Prerequisites + +Before you begin, make sure you have: + +1. Installed OpenAI Agents SDK with voice dependencies: +```bash +pip install 'openai-agents[voice]' +``` + +2. Installed Mem0 SDK: +```bash +pip install mem0ai +``` + +3. Installed other required dependencies: +```bash +pip install numpy sounddevice pydantic +``` + +4. Set up your API keys: + - OpenAI API key for the Agents SDK + - Mem0 API key from the Mem0 Platform + +## Code Breakdown + +Let's break down the key components of this implementation: + +### 1. Setting Up Dependencies and Environment + +```python +# OpenAI Agents SDK imports +from agents import ( + Agent, + function_tool +) +from agents.voice import ( + AudioInput, + SingleAgentVoiceWorkflow, + VoicePipeline +) +from agents.extensions.handoff_prompt import prompt_with_handoff_instructions + +# Mem0 imports +from mem0 import AsyncMemoryClient + +# Set up API keys (replace with your actual keys) +os.environ["OPENAI_API_KEY"] = "your-openai-api-key" +os.environ["MEM0_API_KEY"] = "your-mem0-api-key" + +# Define a global user ID for simplicity +USER_ID = "voice_user" + +# Initialize Mem0 client +mem0_client = AsyncMemoryClient() +``` + +This section handles: +- Importing required modules from OpenAI Agents SDK and Mem0 +- Setting up environment variables for API keys +- Defining a simple user identification system (using a global variable) +- Initializing the Mem0 client that will handle memory operations + +### 2. Memory Tools with Function Decorators + +The `@function_tool` decorator transforms Python functions into callable tools for the OpenAI agent. Here are the key memory tools: + +#### Storing User Memories + +```python +import logging + +# Set up logging at the top of your file +logging.basicConfig( + level=logging.DEBUG, + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', + force=True +) +logger = logging.getLogger("memory_voice_agent") + +# Then use logger in your function tools +@function_tool +async def save_memories( + memory: str +) -> str: + """Store a user memory in memory.""" + # This will be visible in your console + logger.debug(f"Saving memory: {memory} for user {USER_ID}") + + # Store the preference in Mem0 + memory_content = f"User memory - {memory}" + await mem0_client.add( + memory_content, + user_id=USER_ID, + ) + + return f"I've saved your memory: {memory}" +``` + +This function: +- Takes a memory string +- Creates a formatted memory string +- Stores it in Mem0 using the `add()` method +- Includes metadata to categorize the memory for easier retrieval +- Returns a confirmation message that the agent will speak + +#### Finding Relevant Memories + +```python +@function_tool +async def search_memories( + query: str +) -> str: + """ + Find memories relevant to the current conversation. + Args: + query: The search query to find relevant memories + """ + print(f"Finding memories related to: {query}") + results = await mem0_client.search( + query, + user_id=USER_ID, + limit=5, + threshold=0.7, # Higher threshold for more relevant results + output_format="v1.1" + ) + + # Format and return the results + if not results.get('results', []): + return "I don't have any relevant memories about this topic." + + memories = [f"• {result['memory']}" for result in results.get('results', [])] + return "Here's what I remember that might be relevant:\n" + "\n".join(memories) +``` + +This tool: +- Takes a search query string +- Passes it to Mem0's semantic search to find related memories +- Sets a threshold for relevance to ensure quality results +- Returns a formatted list of relevant memories or a default message + +### 3. Creating the Voice Agent + +```python +def create_memory_voice_agent(): + # Create the agent with memory-enabled tools + agent = Agent( + name="Memory Assistant", + instructions=prompt_with_handoff_instructions( + """You're speaking to a human, so be polite and concise. + Always respond in clear, natural English. + You have the ability to remember information about the user. + Use the save_memories tool when the user shares an important information worth remembering. + Use the search_memories tool when you need context from past conversations or user asks you to recall something. + """, + ), + model="gpt-4o", + tools=[save_memories, search_memories], + ) + + return agent +``` + +This function: +- Creates an OpenAI Agent with specific instructions +- Configures it to use gpt-4o (you can use other models) +- Registers the memory-related tools with the agent +- Uses `prompt_with_handoff_instructions` to include standard voice agent behaviors + +### 4. Microphone Recording Functionality + +```python +async def record_from_microphone(duration=5, samplerate=24000): + """Record audio from the microphone for a specified duration.""" + print(f"Recording for {duration} seconds...") + + # Create a buffer to store the recorded audio + frames = [] + + # Callback function to store audio data + def callback(indata, frames_count, time_info, status): + frames.append(indata.copy()) + + # Start recording + with sd.InputStream(samplerate=samplerate, channels=1, callback=callback, dtype=np.int16): + await asyncio.sleep(duration) + + # Combine all frames into a single numpy array + audio_data = np.concatenate(frames) + return audio_data +``` + +This function: +- Creates a simple asynchronous microphone recording function +- Uses the sounddevice library to capture audio input +- Stores frames in a buffer during recording +- Combines frames into a single numpy array when complete +- Returns the audio data for processing + +### 5. Main Loop and Voice Processing + +```python +async def main(): + # Create the agent + agent = create_memory_voice_agent() + + # Set up the voice pipeline + pipeline = VoicePipeline( + workflow=SingleAgentVoiceWorkflow(agent) + ) + + # Configure TTS settings + pipeline.config.tts_settings.voice = "alloy" + pipeline.config.tts_settings.speed = 1.0 + + try: + while True: + # Get user input + print("\nPress Enter to start recording (or 'q' to quit)...") + user_input = input() + if user_input.lower() == 'q': + break + + # Record and process audio + audio_data = await record_from_microphone(duration=5) + audio_input = AudioInput(buffer=audio_data) + result = await pipeline.run(audio_input) + + # Play response and handle events + player = sd.OutputStream(samplerate=24000, channels=1, dtype=np.int16) + player.start() + + agent_response = "" + print("\nAgent response:") + + async for event in result.stream(): + if event.type == "voice_stream_event_audio": + player.write(event.data) + elif event.type == "voice_stream_event_content": + content = event.data + agent_response += content + print(content, end="", flush=True) + + # Save the agent's response to memory + if agent_response: + try: + await mem0_client.add( + f"Agent response: {agent_response}", + user_id=USER_ID, + metadata={"type": "agent_response"} + ) + except Exception as e: + print(f"Failed to store memory: {e}") + + except KeyboardInterrupt: + print("\nExiting...") +``` + +This main function orchestrates the entire process: +1. Creates the memory-enabled voice agent +2. Sets up the voice pipeline with TTS settings +3. Implements an interactive loop for recording and processing voice input +4. Handles streaming of response events (both audio and text) +5. Automatically saves the agent's responses to memory +6. Includes proper error handling and exit mechanisms + +## Create a Memory-Enabled Voice Agent + +Now that we've explained each component, here's the complete implementation that combines OpenAI Agents SDK for voice with Mem0's memory capabilities: + +```python +import asyncio +import os +import logging +from typing import Optional, List, Dict, Any +import numpy as np +import sounddevice as sd +from pydantic import BaseModel + +# OpenAI Agents SDK imports +from agents import ( + Agent, + function_tool +) +from agents.voice import ( + AudioInput, + SingleAgentVoiceWorkflow, + VoicePipeline +) +from agents.extensions.handoff_prompt import prompt_with_handoff_instructions + +# Mem0 imports +from mem0 import AsyncMemoryClient + +# Set up API keys (replace with your actual keys) +os.environ["OPENAI_API_KEY"] = "your-openai-api-key" +os.environ["MEM0_API_KEY"] = "your-mem0-api-key" + +# Define a global user ID for simplicity +USER_ID = "voice_user" + +# Initialize Mem0 client +mem0_client = AsyncMemoryClient() + +# Create tools that utilize Mem0's memory +@function_tool +async def save_memories( + memory: str +) -> str: + """ + Store a user memory in memory. + Args: + memory: The memory to save + """ + print(f"Saving memory: {memory} for user {USER_ID}") + + # Store the preference in Mem0 + memory_content = f"User memory - {memory}" + await mem0_client.add( + memory_content, + user_id=USER_ID, + ) + + return f"I've saved your memory: {memory}" + +@function_tool +async def search_memories( + query: str +) -> str: + """ + Find memories relevant to the current conversation. + Args: + query: The search query to find relevant memories + """ + print(f"Finding memories related to: {query}") + results = await mem0_client.search( + query, + user_id=USER_ID, + limit=5, + threshold=0.7, # Higher threshold for more relevant results + output_format="v1.1" + ) + + # Format and return the results + if not results.get('results', []): + return "I don't have any relevant memories about this topic." + + memories = [f"• {result['memory']}" for result in results.get('results', [])] + return "Here's what I remember that might be relevant:\n" + "\n".join(memories) + +# Create the agent with memory-enabled tools +def create_memory_voice_agent(): + # Create the agent with memory-enabled tools + agent = Agent( + name="Memory Assistant", + instructions=prompt_with_handoff_instructions( + """You're speaking to a human, so be polite and concise. + Always respond in clear, natural English. + You have the ability to remember information about the user. + Use the save_memories tool when the user shares an important information worth remembering. + Use the search_memories tool when you need context from past conversations or user asks you to recall something. + """, + ), + model="gpt-4o", + tools=[save_memories, search_memories], + ) + + return agent + +async def record_from_microphone(duration=5, samplerate=24000): + """Record audio from the microphone for a specified duration.""" + print(f"Recording for {duration} seconds...") + + # Create a buffer to store the recorded audio + frames = [] + + # Callback function to store audio data + def callback(indata, frames_count, time_info, status): + frames.append(indata.copy()) + + # Start recording + with sd.InputStream(samplerate=samplerate, channels=1, callback=callback, dtype=np.int16): + await asyncio.sleep(duration) + + # Combine all frames into a single numpy array + audio_data = np.concatenate(frames) + return audio_data + +async def main(): + print("Starting Memory Voice Agent") + + # Create the agent and context + agent = create_memory_voice_agent() + + # Set up the voice pipeline + pipeline = VoicePipeline( + workflow=SingleAgentVoiceWorkflow(agent) + ) + + # Configure TTS settings + pipeline.config.tts_settings.voice = "alloy" + pipeline.config.tts_settings.speed = 1.0 + + try: + while True: + # Get user input + print("\nPress Enter to start recording (or 'q' to quit)...") + user_input = input() + if user_input.lower() == 'q': + break + + # Record and process audio + audio_data = await record_from_microphone(duration=5) + audio_input = AudioInput(buffer=audio_data) + + print("Processing your request...") + + # Process the audio input + result = await pipeline.run(audio_input) + + # Create an audio player + player = sd.OutputStream(samplerate=24000, channels=1, dtype=np.int16) + player.start() + + # Store the agent's response for adding to memory + agent_response = "" + + print("\nAgent response:") + # Play the audio stream as it comes in + async for event in result.stream(): + if event.type == "voice_stream_event_audio": + player.write(event.data) + elif event.type == "voice_stream_event_content": + # Accumulate and print the text response + content = event.data + agent_response += content + print(content, end="", flush=True) + + print("\n") + + # Example of saving the conversation to Mem0 after completion + if agent_response: + try: + await mem0_client.add( + f"Agent response: {agent_response}", + user_id=USER_ID, + metadata={"type": "agent_response"} + ) + except Exception as e: + print(f"Failed to store memory: {e}") + + except KeyboardInterrupt: + print("\nExiting...") + +if __name__ == "__main__": + asyncio.run(main()) +``` + +## Key Features of This Implementation + +This implementation offers several key features: + +1. **Simplified User Management**: Uses a global `USER_ID` variable for simplicity, but can be extended to manage multiple users. + +2. **Real Microphone Input**: Includes a `record_from_microphone()` function that captures actual voice input from your microphone. + +3. **Interactive Voice Loop**: Implements a continuous interaction loop, allowing for multiple back-and-forth exchanges. + +4. **Memory Management Tools**: + - `save_memories`: Stores user memories in Mem0 + - `search_memories`: Searches for relevant past information + +5. **Voice Configuration**: Demonstrates how to configure TTS settings for the voice response. + +## Running the Example + +To run this example: + +1. Replace the placeholder API keys with your actual keys +2. Make sure your microphone is properly connected +3. Run the script with Python 3.8 or newer +4. Press Enter to start recording, then speak your request +5. Press 'q' to quit the application + +The agent will listen to your request, process it through the OpenAI model, utilize Mem0 for memory operations as needed, and respond both through text output and voice speech. + +## Best Practices for Voice Agents with Memory + +1. **Optimizing Memory for Voice**: Keep memories concise and relevant for voice responses. + +2. **Forgetting Mechanism**: Implement a way to delete or expire memories that are no longer relevant. + +3. **Context Preservation**: Store enough context with each memory to make retrieval effective. + +4. **Error Handling**: Implement robust error handling for memory operations, as voice interactions should continue smoothly even if memory operations fail. + +## Conclusion + +By combining OpenAI's Agents SDK with Mem0's memory capabilities, you can create voice agents that maintain persistent memory of user preferences and past interactions. This significantly enhances the user experience by making conversations more natural and personalized. + +As you build your voice application, experiment with different memory strategies and filtering approaches to find the optimal balance between comprehensive memory and efficient retrieval for your specific use case. + +## Debugging Function Tools + +When working with the OpenAI Agents SDK, you might notice that regular `print()` statements inside `@function_tool` decorated functions don't appear in your console output. This is because the Agents SDK captures and redirects standard output when executing these functions. + +To effectively debug your function tools, use Python's `logging` module instead: + +```python +import logging + +# Set up logging at the top of your file +logging.basicConfig( + level=logging.DEBUG, + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', + force=True +) +logger = logging.getLogger("memory_voice_agent") + +# Then use logger in your function tools +@function_tool +async def save_memories( + memory: str +) -> str: + """Store a user memory in memory.""" + # This will be visible in your console + logger.debug(f"Saving memory: {memory} for user {USER_ID}") + + # Rest of your function... +``` \ No newline at end of file diff --git a/docs/v0x/examples/mem0-with-ollama.mdx b/docs/v0x/examples/mem0-with-ollama.mdx new file mode 100644 index 000000000..de57feb33 --- /dev/null +++ b/docs/v0x/examples/mem0-with-ollama.mdx @@ -0,0 +1,72 @@ +--- +title: Mem0 with Ollama +--- + +## Running Mem0 Locally with Ollama + +Mem0 can be utilized entirely locally by leveraging Ollama for both the embedding model and the language model (LLM). This guide will walk you through the necessary steps and provide the complete code to get you started. + +### Overview + +By using Ollama, you can run Mem0 locally, which allows for greater control over your data and models. This setup uses Ollama for both the embedding model and the language model, providing a fully local solution. + +### Setup + +Before you begin, ensure you have Mem0 and Ollama installed and properly configured on your local machine. + +### Full Code Example + +Below is the complete code to set up and use Mem0 locally with Ollama: + +```python +from mem0 import Memory + +config = { + "vector_store": { + "provider": "qdrant", + "config": { + "collection_name": "test", + "host": "localhost", + "port": 6333, + "embedding_model_dims": 768, # Change this according to your local model's dimensions + }, + }, + "llm": { + "provider": "ollama", + "config": { + "model": "llama3.1:latest", + "temperature": 0, + "max_tokens": 2000, + "ollama_base_url": "http://localhost:11434", # Ensure this URL is correct + }, + }, + "embedder": { + "provider": "ollama", + "config": { + "model": "nomic-embed-text:latest", + # Alternatively, you can use "snowflake-arctic-embed:latest" + "ollama_base_url": "http://localhost:11434", + }, + }, +} + +# Initialize Memory with the configuration +m = Memory.from_config(config) + +# Add a memory +m.add("I'm visiting Paris", user_id="john") + +# Retrieve memories +memories = m.get_all(user_id="john") +``` + +### Key Points + +- **Configuration**: The setup involves configuring the vector store, language model, and embedding model to use local resources. +- **Vector Store**: Qdrant is used as the vector store, running on localhost. +- **Language Model**: Ollama is used as the LLM provider, with the "llama3.1:latest" model. +- **Embedding Model**: Ollama is also used for embeddings, with the "nomic-embed-text:latest" model. + +### Conclusion + +This local setup of Mem0 using Ollama provides a fully self-contained solution for memory management and AI interactions. It allows for greater control over your data and models while still leveraging the powerful capabilities of Mem0. \ No newline at end of file diff --git a/docs/v0x/examples/memory-guided-content-writing.mdx b/docs/v0x/examples/memory-guided-content-writing.mdx new file mode 100644 index 000000000..1f8b4f195 --- /dev/null +++ b/docs/v0x/examples/memory-guided-content-writing.mdx @@ -0,0 +1,218 @@ +--- +title: Memory-Guided Content Writing +--- + +This guide demonstrates how to leverage **Mem0** to streamline content writing by applying your unique writing style and preferences using persistent memory. + +## Why Use Mem0? + +Integrating Mem0 into your writing workflow helps you: + +1. **Store persistent writing preferences** ensuring consistent tone, formatting, and structure. +2. **Automate content refinement** by retrieving preferences when rewriting or reviewing content. +3. **Scale your writing style** so it applies consistently across multiple documents or sessions. + +## Setup + +```python +import os +from openai import OpenAI +from mem0 import MemoryClient + +os.environ["MEM0_API_KEY"] = "your-mem0-api-key" +os.environ["OPENAI_API_KEY"] = "your-openai-api-key" + + +# Set up Mem0 and OpenAI client +client = MemoryClient() +openai = OpenAI() + +USER_ID = "content_writer" +RUN_ID = "smart_editing_session" +``` + +## **Storing Your Writing Preferences in Mem0** + +```python +def store_writing_preferences(): + """Store your writing preferences in Mem0.""" + + preferences = """My writing preferences: +1. Use headings and sub-headings for structure. +2. Keep paragraphs concise (8–10 sentences max). +3. Incorporate specific numbers and statistics. +4. Provide concrete examples. +5. Use bullet points for clarity. +6. Avoid jargon and buzzwords.""" + + messages = [ + {"role": "user", "content": "Here are my writing style preferences."}, + {"role": "assistant", "content": preferences} + ] + + response = client.add( + messages, + user_id=USER_ID, + run_id=RUN_ID, + metadata={"type": "preferences", "category": "writing_style"} + ) + + return response +``` + +## **Editing Content Using Stored Preferences** + +```python +def apply_writing_style(original_content): + """Use preferences stored in Mem0 to guide content rewriting.""" + + results = client.search( + query="What are my writing style preferences?", + version="v2", + filters={ + "AND": [ + { + "user_id": USER_ID + }, + { + "run_id": RUN_ID + } + ] + }, + ) + + if not results: + print("No preferences found.") + return None + + preferences = "\n".join(r["memory"] for r in results.get('results', [])) + + system_prompt = f""" +You are a writing assistant. + +Apply the following writing style preferences to improve the user's content: + +Preferences: +{preferences} +""" + + messages = [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": f"""Original Content: + {original_content}"""} + ] + + response = openai.chat.completions.create( + model="gpt-4o-mini", + messages=messages + ) + clean_response = response.choices[0].message.content.strip() + + return clean_response +``` + +## **Complete Workflow: Content Editing** + +```python +def content_writing_workflow(content): + """Automated workflow for editing a document based on writing preferences.""" + + # Store writing preferences (if not already stored) + store_writing_preferences() # Ideally done once, or with a conditional check + + # Edit the document with Mem0 preferences + edited_content = apply_writing_style(content) + + if not edited_content: + return "Failed to edit document." + + # Display results + print("\n=== ORIGINAL DOCUMENT ===\n") + print(content) + + print("\n=== EDITED DOCUMENT ===\n") + print(edited_content) + + return edited_content +``` + +## **Example Usage** + +```python +# Define your document +original_content = """Project Proposal + +The following proposal outlines our strategy for the Q3 marketing campaign. +We believe this approach will significantly increase our market share. + +Increase brand awareness +Boost sales by 15% +Expand our social media following + +We plan to launch the campaign in July and continue through September. +""" + +# Run the workflow +result = content_writing_workflow(original_content) +``` + +## **Expected Output** + +Your document will be transformed into a structured, well-formatted version based on your preferences. + +### **Original Document** +``` +Project Proposal + +The following proposal outlines our strategy for the Q3 marketing campaign. +We believe this approach will significantly increase our market share. + +Increase brand awareness +Boost sales by 15% +Expand our social media following + +We plan to launch the campaign in July and continue through September. +``` + +### **Edited Document** +``` +# **Project Proposal** + +## **Q3 Marketing Campaign Strategy** + +This proposal outlines our strategy for the Q3 marketing campaign. We aim to significantly increase our market share with this approach. + +### **Objectives** + +- **Increase Brand Awareness**: Implement targeted advertising and community engagement to enhance visibility. +- **Boost Sales by 15%**: Increase sales by 15% compared to Q2 figures. +- **Expand Social Media Following**: Grow our social media audience by 20%. + +### **Timeline** + +- **Launch Date**: July +- **Duration**: July – September + +### **Key Actions** + +- **Targeted Advertising**: Utilize platforms like Google Ads and Facebook to reach specific demographics. +- **Community Engagement**: Host webinars and live Q&A sessions. +- **Content Creation**: Produce engaging videos and infographics. + +### **Supporting Data** + +- **Previous Campaign Success**: Our Q2 campaign increased sales by 12%. We will refine similar strategies for Q3. +- **Social Media Growth**: Last year, our Instagram followers grew by 25% during a similar campaign. + +### **Conclusion** + +We believe this strategy will effectively increase our market share. To achieve these goals, we need your support and collaboration. Let’s work together to make this campaign a success. Please review the proposal and provide your feedback by the end of the week. +``` + +Mem0 enables a seamless, intelligent content-writing workflow, perfect for content creators, marketers, and technical writers looking to scale their personal tone and structure across work. + +## Help & Resources + +- [Mem0 Platform](https://app.mem0.ai/) + + \ No newline at end of file diff --git a/docs/v0x/examples/multimodal-demo.mdx b/docs/v0x/examples/multimodal-demo.mdx new file mode 100644 index 000000000..ad5bbf776 --- /dev/null +++ b/docs/v0x/examples/multimodal-demo.mdx @@ -0,0 +1,31 @@ +--- +title: Multimodal Demo with Mem0 +--- + +Enhance your AI interactions with **Mem0**'s multimodal capabilities. Mem0 now supports image understanding, allowing for richer context and more natural interactions across supported AI platforms. + +> Experience the power of multimodal AI! Test out Mem0's image understanding capabilities at [multimodal-demo.mem0.ai](https://multimodal-demo.mem0.ai) + +## Features + +- **Image Understanding**: Share and discuss images with AI assistants while maintaining context. +- **Smart Visual Context**: Automatically capture and reference visual elements in conversations. +- **Cross-Modal Memory**: Link visual and textual information seamlessly in your memory layer. +- **Cross-Session Recall**: Reference previously discussed visual content across different conversations. +- **Seamless Integration**: Works naturally with existing chat interfaces for a smooth experience. + +## How It Works + +1. **Upload Visual Content**: Simply drag and drop or paste images into your conversations. +2. **Natural Interaction**: Discuss the visual content naturally with AI assistants. +3. **Memory Integration**: Visual context is automatically stored and linked with your conversation history. +4. **Persistent Recall**: Retrieve and reference past visual content effortlessly. + +## Demo Video + + + +## Try It Out + +Visit [multimodal-demo.mem0.ai](https://multimodal-demo.mem0.ai) to experience Mem0's multimodal capabilities firsthand. Upload images and see how Mem0 understands and remembers visual context across your conversations. + diff --git a/docs/v0x/examples/openai-inbuilt-tools.mdx b/docs/v0x/examples/openai-inbuilt-tools.mdx new file mode 100644 index 000000000..e1afa6b90 --- /dev/null +++ b/docs/v0x/examples/openai-inbuilt-tools.mdx @@ -0,0 +1,312 @@ +--- +title: OpenAI Inbuilt Tools +--- + +Integrate Mem0’s memory capabilities with OpenAI’s Inbuilt Tools to create AI agents with persistent memory. + +## Getting Started + +### Installation + +```bash +npm install mem0ai openai zod +``` + +## Environment Setup + +Save your Mem0 and OpenAI API keys in a `.env` file: + +``` +MEM0_API_KEY=your_mem0_api_key +OPENAI_API_KEY=your_openai_api_key +``` + +Get your Mem0 API key from the [Mem0 Dashboard](https://app.mem0.ai/dashboard/api-keys). + +### Configuration + +```javascript +const mem0Config = { + apiKey: process.env.MEM0_API_KEY, + user_id: "sample-user", +}; + +const openAIClient = new OpenAI(); +const mem0Client = new MemoryClient(mem0Config); +``` + +### Adding Memories + +Store user preferences, past interactions, or any relevant information: + +```javascript JavaScript +async function addUserPreferences() { + const mem0Client = new MemoryClient(mem0Config); + + const userPreferences = "I Love BMW, Audi and Porsche. I Hate Mercedes. I love Red cars and Maroon cars. I have a budget of 120K to 150K USD. I like Audi the most."; + + await mem0Client.add([{ + role: "user", + content: userPreferences, + }], mem0Config); +} + +await addUserPreferences(); +``` + +```json Output (Memories) + [ + { + "id": "ff9f3367-9e83-415d-b9c5-dc8befd9a4b4", + "data": { "memory": "Loves BMW, Audi, and Porsche" }, + "event": "ADD" + }, + { + "id": "04172ce6-3d7b-45a3-b4a1-ee9798593cb4", + "data": { "memory": "Hates Mercedes" }, + "event": "ADD" + }, + { + "id": "db363a5d-d258-4953-9e4c-777c120de34d", + "data": { "memory": "Loves red cars and maroon cars" }, + "event": "ADD" + }, + { + "id": "5519aaad-a2ac-4c0d-81d7-0d55c6ecdba8", + "data": { "memory": "Has a budget of 120K to 150K USD" }, + "event": "ADD" + }, + { + "id": "523b7693-7344-4563-922f-5db08edc8634", + "data": { "memory": "Likes Audi the most" }, + "event": "ADD" + } +] +``` + +### Retrieving Memories + +Search for relevant memories based on the current user input: + +```javascript +const relevantMemories = await mem0Client.search(userInput, mem0Config); +``` + +### Structured Responses with Zod + +Define structured response schemas to get consistent output formats: + +```javascript +// Define the schema for a car recommendation +const CarSchema = z.object({ + car_name: z.string(), + car_price: z.string(), + car_url: z.string(), + car_image: z.string(), + car_description: z.string(), +}); + +// Schema for a list of car recommendations +const Cars = z.object({ + cars: z.array(CarSchema), +}); + +// Create a function tool based on the schema +const carRecommendationTool = zodResponsesFunction({ + name: "carRecommendations", + parameters: Cars +}); + +// Use the tool in your OpenAI request +const response = await openAIClient.responses.create({ + model: "gpt-4o", + tools: [{ type: "web_search_preview" }, carRecommendationTool], + input: `${getMemoryString(relevantMemories)}\n${userInput}`, +}); +``` + +### Using Web Search + +Combine memory with web search for up-to-date recommendations: + +```javascript +const response = await openAIClient.responses.create({ + model: "gpt-4o", + tools: [{ type: "web_search_preview" }, carRecommendationTool], + input: `${getMemoryString(relevantMemories)}\n${userInput}`, +}); +``` + +## Examples + +### Complete Car Recommendation System + +```javascript +import MemoryClient from "mem0ai"; +import { OpenAI } from "openai"; +import { zodResponsesFunction } from "openai/helpers/zod"; +import { z } from "zod"; +import dotenv from 'dotenv'; + +dotenv.config(); + +const mem0Config = { + apiKey: process.env.MEM0_API_KEY, + user_id: "sample-user", +}; + +async function run() { + // Responses without memories + console.log("\n\nRESPONSES WITHOUT MEMORIES\n\n"); + await main(); + + // Adding sample memories + await addSampleMemories(); + + // Responses with memories + console.log("\n\nRESPONSES WITH MEMORIES\n\n"); + await main(true); +} + +// OpenAI Response Schema +const CarSchema = z.object({ + car_name: z.string(), + car_price: z.string(), + car_url: z.string(), + car_image: z.string(), + car_description: z.string(), +}); + +const Cars = z.object({ + cars: z.array(CarSchema), +}); + +async function main(memory = false) { + const openAIClient = new OpenAI(); + const mem0Client = new MemoryClient(mem0Config); + + const input = "Suggest me some cars that I can buy today."; + + const tool = zodResponsesFunction({ name: "carRecommendations", parameters: Cars }); + + // Store the user input as a memory + await mem0Client.add([{ + role: "user", + content: input, + }], mem0Config); + + // Search for relevant memories + let relevantMemories = [] + if (memory) { + relevantMemories = await mem0Client.search(input, mem0Config); + } + + const response = await openAIClient.responses.create({ + model: "gpt-4o", + tools: [{ type: "web_search_preview" }, tool], + input: `${getMemoryString(relevantMemories)}\n${input}`, + }); + + console.log(response.output); +} + +async function addSampleMemories() { + const mem0Client = new MemoryClient(mem0Config); + + const myInterests = "I Love BMW, Audi and Porsche. I Hate Mercedes. I love Red cars and Maroon cars. I have a budget of 120K to 150K USD. I like Audi the most."; + + await mem0Client.add([{ + role: "user", + content: myInterests, + }], mem0Config); +} + +const getMemoryString = (memories) => { + const MEMORY_STRING_PREFIX = "These are the memories I have stored. Give more weightage to the question by users and try to answer that first. You have to modify your answer based on the memories I have provided. If the memories are irrelevant you can ignore them. Also don't reply to this section of the prompt, or the memories, they are only for your reference. The MEMORIES of the USER are: \n\n"; + const memoryString = (memories?.results || memories).map((mem) => `${mem.memory}`).join("\n") ?? ""; + return memoryString.length > 0 ? `${MEMORY_STRING_PREFIX}${memoryString}` : ""; +}; + +run().catch(console.error); +``` + +### Responses + + + ```json Without Memories + { + "cars": [ + { + "car_name": "Toyota Camry", + "car_price": "$25,000", + "car_url": "https://www.toyota.com/camry/", + "car_image": "https://link-to-toyota-camry-image.com", + "car_description": "Reliable mid-size sedan with great fuel efficiency." + }, + { + "car_name": "Honda Accord", + "car_price": "$26,000", + "car_url": "https://www.honda.com/accord/", + "car_image": "https://link-to-honda-accord-image.com", + "car_description": "Comfortable and spacious with advanced safety features." + }, + { + "car_name": "Ford Mustang", + "car_price": "$28,000", + "car_url": "https://www.ford.com/mustang/", + "car_image": "https://link-to-ford-mustang-image.com", + "car_description": "Iconic sports car with powerful engine options." + }, + { + "car_name": "Tesla Model 3", + "car_price": "$38,000", + "car_url": "https://www.tesla.com/model3", + "car_image": "https://link-to-tesla-model3-image.com", + "car_description": "Electric vehicle with advanced technology and long range." + }, + { + "car_name": "Chevrolet Equinox", + "car_price": "$24,000", + "car_url": "https://www.chevrolet.com/equinox/", + "car_image": "https://link-to-chevron-equinox-image.com", + "car_description": "Compact SUV with a spacious interior and user-friendly technology." + } + ] + } + ``` + + ```json With Memories + { + "cars": [ + { + "car_name": "Audi RS7", + "car_price": "$118,500", + "car_url": "https://www.audiusa.com/us/web/en/models/rs7/2023/overview.html", + "car_image": "https://www.audiusa.com/content/dam/nemo/us/models/rs7/my23/gallery/1920x1080_AOZ_A717_191004.jpg", + "car_description": "The Audi RS7 is a high-performance hatchback with a sleek design, powerful 591-hp twin-turbo V8, and luxurious interior. It's available in various colors including red." + }, + { + "car_name": "Porsche Panamera GTS", + "car_price": "$129,300", + "car_url": "https://www.porsche.com/usa/models/panamera/panamera-models/panamera-gts/", + "car_image": "https://files.porsche.com/filestore/image/multimedia/noneporsche-panamera-gts-sample-m02-high/normal/8a6327c3-6c7f-4c6f-a9a8-fb9f58b21795;sP;twebp/porsche-normal.webp", + "car_description": "The Porsche Panamera GTS is a luxury sports sedan with a 473-hp V8 engine, exquisite handling, and available in stunning red. Balances sportiness and comfort." + }, + { + "car_name": "BMW M5", + "car_price": "$105,500", + "car_url": "https://www.bmwusa.com/vehicles/m-models/m5/sedan/overview.html", + "car_image": "https://www.bmwusa.com/content/dam/bmwusa/M/m5/2023/bmw-my23-m5-sapphire-black-twilight-purple-exterior-02.jpg", + "car_description": "The BMW M5 is a powerhouse sedan with a 600-hp V8 engine, known for its great handling and luxury. It comes in several distinctive colors including maroon." + } + ] + } + ``` + + +## Resources + +- [Mem0 Documentation](https://docs.mem0.ai) +- [Mem0 Dashboard](https://app.mem0.ai/dashboard) +- [API Reference](https://docs.mem0.ai/api-reference) +- [OpenAI Documentation](https://platform.openai.com/docs) \ No newline at end of file diff --git a/docs/v0x/examples/personal-ai-tutor.mdx b/docs/v0x/examples/personal-ai-tutor.mdx new file mode 100644 index 000000000..220577aa7 --- /dev/null +++ b/docs/v0x/examples/personal-ai-tutor.mdx @@ -0,0 +1,111 @@ +--- +title: Personalized AI Tutor +--- + +You can create a personalized AI Tutor using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started. + +## Overview + +The Personalized AI Tutor leverages Mem0 to retain information across interactions, enabling a tailored learning experience. By integrating with OpenAI's GPT-4 model, the tutor can provide detailed and context-aware responses to user queries. + +## Setup +Before you begin, ensure you have the required dependencies installed. You can install the necessary packages using pip: + +```bash +pip install openai mem0ai +``` + +## Full Code Example + +Below is the complete code to create and interact with a Personalized AI Tutor using Mem0: + +```python +import os +from openai import OpenAI +from mem0 import Memory + +# Set the OpenAI API key +os.environ['OPENAI_API_KEY'] = 'sk-xxx' + +# Initialize the OpenAI client +client = OpenAI() + +class PersonalAITutor: + def __init__(self): + """ + Initialize the PersonalAITutor with memory configuration and OpenAI client. + """ + config = { + "vector_store": { + "provider": "qdrant", + "config": { + "host": "localhost", + "port": 6333, + } + }, + } + self.memory = Memory.from_config(config) + self.client = client + self.app_id = "app-1" + + def ask(self, question, user_id=None): + """ + Ask a question to the AI and store the relevant facts in memory + + :param question: The question to ask the AI. + :param user_id: Optional user ID to associate with the memory. + """ + # Start a streaming response request to the AI + response = self.client.responses.create( + model="gpt-4o", + instructions="You are a personal AI Tutor.", + input=question, + stream=True + ) + + # Store the question in memory + self.memory.add(question, user_id=user_id, metadata={"app_id": self.app_id}) + + # Print the response from the AI in real-time + for event in response: + if event.type == "response.output_text.delta": + print(event.delta, end="") + + def get_memories(self, user_id=None): + """ + Retrieve all memories associated with the given user ID. + + :param user_id: Optional user ID to filter memories. + :return: List of memories. + """ + return self.memory.get_all(user_id=user_id) + +# Instantiate the PersonalAITutor +ai_tutor = PersonalAITutor() + +# Define a user ID +user_id = "john_doe" + +# Ask a question +ai_tutor.ask("I am learning introduction to CS. What is queue? Briefly explain.", user_id=user_id) +``` + +### Fetching Memories + +You can fetch all the memories at any point in time using the following code: + +```python +memories = ai_tutor.get_memories(user_id=user_id) +for m in memories['results']: + print(m['memory']) +``` + +### Key Points + +- **Initialization**: The PersonalAITutor class is initialized with the necessary memory configuration and OpenAI client setup. +- **Asking Questions**: The ask method sends a question to the AI and stores the relevant information in memory. +- **Retrieving Memories**: The get_memories method fetches all stored memories associated with a user. + +### Conclusion + +As the conversation progresses, Mem0's memory automatically updates based on the interactions, providing a continuously improving personalized learning experience. This setup ensures that the AI Tutor can offer contextually relevant and accurate responses, enhancing the overall educational process. diff --git a/docs/v0x/examples/personal-travel-assistant.mdx b/docs/v0x/examples/personal-travel-assistant.mdx new file mode 100644 index 000000000..81fb753db --- /dev/null +++ b/docs/v0x/examples/personal-travel-assistant.mdx @@ -0,0 +1,202 @@ +--- +title: Personal AI Travel Assistant +--- + + +Create a personalized AI Travel Assistant using Mem0. This guide provides step-by-step instructions and the complete code to get you started. + +## Overview + +The Personalized AI Travel Assistant uses Mem0 to store and retrieve information across interactions, enabling a tailored travel planning experience. It integrates with OpenAI's GPT-4 model to provide detailed and context-aware responses to user queries. + +## Setup + +Install the required dependencies using pip: + +```bash +pip install openai mem0ai +``` + +## Full Code Example + +Here's the complete code to create and interact with a Personalized AI Travel Assistant using Mem0: + + + +```python After v1.1 +import os +from openai import OpenAI +from mem0 import Memory + +# Set the OpenAI API key +os.environ['OPENAI_API_KEY'] = "sk-xxx" + +config = { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4o", + "temperature": 0.1, + "max_tokens": 2000, + } + }, + "embedder": { + "provider": "openai", + "config": { + "model": "text-embedding-3-large" + } + }, + "vector_store": { + "provider": "qdrant", + "config": { + "collection_name": "test", + "embedding_model_dims": 3072, + } + }, + "version": "v1.1", +} + +class PersonalTravelAssistant: + def __init__(self): + self.client = OpenAI() + self.memory = Memory.from_config(config) + self.messages = [{"role": "system", "content": "You are a personal AI Assistant."}] + + def ask_question(self, question, user_id): + # Fetch previous related memories + previous_memories = self.search_memories(question, user_id=user_id) + + # Build the prompt + system_message = "You are a personal AI Assistant." + + if previous_memories: + prompt = f"{system_message}\n\nUser input: {question}\nPrevious memories: {', '.join(previous_memories)}" + else: + prompt = f"{system_message}\n\nUser input: {question}" + + # Generate response using Responses API + response = self.client.responses.create( + model="gpt-4o", + input=prompt + ) + + # Extract answer from the response + answer = response.output[0].content[0].text + + # Store the question in memory + self.memory.add(question, user_id=user_id) + return answer + + def get_memories(self, user_id): + memories = self.memory.get_all(user_id=user_id) + return [m['memory'] for m in memories['results']] + + def search_memories(self, query, user_id): + memories = self.memory.search(query, user_id=user_id) + return [m['memory'] for m in memories['results']] + +# Usage example +user_id = "traveler_123" +ai_assistant = PersonalTravelAssistant() + +def main(): + while True: + question = input("Question: ") + if question.lower() in ['q', 'exit']: + print("Exiting...") + break + + answer = ai_assistant.ask_question(question, user_id=user_id) + print(f"Answer: {answer}") + memories = ai_assistant.get_memories(user_id=user_id) + print("Memories:") + for memory in memories: + print(f"- {memory}") + print("-----") + +if __name__ == "__main__": + main() +``` + +```python Before v1.1 +import os +from openai import OpenAI +from mem0 import Memory + +# Set the OpenAI API key +os.environ['OPENAI_API_KEY'] = 'sk-xxx' + +class PersonalTravelAssistant: + def __init__(self): + self.client = OpenAI() + self.memory = Memory() + self.messages = [{"role": "system", "content": "You are a personal AI Assistant."}] + + def ask_question(self, question, user_id): + # Fetch previous related memories + previous_memories = self.search_memories(question, user_id=user_id) + prompt = question + if previous_memories: + prompt = f"User input: {question}\n Previous memories: {previous_memories}" + self.messages.append({"role": "user", "content": prompt}) + + # Generate response using GPT-4o + response = self.client.chat.completions.create( + model="gpt-4o", + messages=self.messages + ) + answer = response.choices[0].message.content + self.messages.append({"role": "assistant", "content": answer}) + + # Store the question in memory + self.memory.add(question, user_id=user_id) + return answer + + def get_memories(self, user_id): + memories = self.memory.get_all(user_id=user_id) + return [m['memory'] for m in memories.get('results', [])] + + def search_memories(self, query, user_id): + memories = self.memory.search(query, user_id=user_id) + return [m['memory'] for m in memories.get('results', [])] + +# Usage example +user_id = "traveler_123" +ai_assistant = PersonalTravelAssistant() + +def main(): + while True: + question = input("Question: ") + if question.lower() in ['q', 'exit']: + print("Exiting...") + break + + answer = ai_assistant.ask_question(question, user_id=user_id) + print(f"Answer: {answer}") + memories = ai_assistant.get_memories(user_id=user_id) + print("Memories:") + for memory in memories: + print(f"- {memory}") + print("-----") + +if __name__ == "__main__": + main() +``` + + + +## Key Components + +- **Initialization**: The `PersonalTravelAssistant` class is initialized with the OpenAI client and Mem0 memory setup. +- **Asking Questions**: The `ask_question` method sends a question to the AI, incorporates previous memories, and stores new information. +- **Memory Management**: The `get_memories` and search_memories methods handle retrieval and searching of stored memories. + +## Usage + +1. Set your OpenAI API key in the environment variable. +2. Instantiate the `PersonalTravelAssistant`. +3. Use the `main()` function to interact with the assistant in a loop. + +## Conclusion + +This Personalized AI Travel Assistant leverages Mem0's memory capabilities to provide context-aware responses. As you interact with it, the assistant learns and improves, offering increasingly personalized travel advice and information. \ No newline at end of file diff --git a/docs/v0x/examples/personalized-deep-research.mdx b/docs/v0x/examples/personalized-deep-research.mdx new file mode 100644 index 000000000..66ac2f718 --- /dev/null +++ b/docs/v0x/examples/personalized-deep-research.mdx @@ -0,0 +1,67 @@ +--- +title: Personalized Deep Research +--- + +Deep Research is an intelligent agent that synthesizes large amounts of online data and completes complex research tasks, customized to your unique preferences and insights. Built on Mem0's technology, it enhances AI-driven online exploration with personalized memories. + +You can checkout GitHub repositry here: [Personalized Deep Research](https://github.com/mem0ai/personalized-deep-research/tree/mem0) + +## Overview + +Deep Research leverages Mem0's memory capabilities to: +- Synthesize large amounts of online data +- Complete complex research tasks +- Customize results to your preferences +- Store and utilize personal insights +- Maintain context across research sessions + +## Demo + +Watch Deep Research in action: + + + +## Features + +### 1. Personalized Research +- Analyzes your background and expertise +- Tailors research depth and complexity to your level +- Incorporates your previous research context + +### 2. Comprehensive Data Synthesis +- Processes multiple online sources +- Extracts relevant information +- Provides coherent summaries + +### 3. Memory Integration +- Stores research findings for future reference +- Maintains context across sessions +- Links related research topics + +### 4. Interactive Exploration +- Allows real-time query refinement +- Supports follow-up questions +- Enables deep-diving into specific areas + +## Use Cases + +- **Academic Research**: Literature reviews, thesis research, paper writing +- **Market Research**: Industry analysis, competitor research, trend identification +- **Technical Research**: Technology evaluation, solution comparison +- **Business Research**: Strategic planning, opportunity analysis + + +## Try It Out + +> To try it yourself, clone the repository and follow the instructions in the README to run it locally or deploy it. + +- [Personalized Deep Research GitHub](https://github.com/mem0ai/personalized-deep-research/tree/mem0) diff --git a/docs/v0x/examples/personalized-search-tavily-mem0.mdx b/docs/v0x/examples/personalized-search-tavily-mem0.mdx new file mode 100644 index 000000000..d26d655ae --- /dev/null +++ b/docs/v0x/examples/personalized-search-tavily-mem0.mdx @@ -0,0 +1,190 @@ +--- +title: 'Personalized Search with Mem0 and Tavily' +--- + + + +Imagine asking a search assistant for "coffee shops nearby" and instead of generic results, it shows remote-work-friendly cafes with great wifi in your city because it remembers you mentioned working remotely before. Or when you search for "lunchbox ideas for kids" it knows you have a **7-year-old daughter** and recommends **peanut-free options** that align with her allergy. + +That's what we are going to build today, a **Personalized Search Assistant** powered by **Mem0** for memory and [Tavily](https://tavily.com) for real-time search. + + +## Why Personalized Search + +Most assistants treat every query like they’ve never seen you before. That means repeating yourself about your location, diet, or preferences, and getting results that feel generic. + +- With **Mem0**, your assistant builds a memory of the user’s world. +- With **Tavily**, it fetches fresh and accurate results in real time. + +Together, they make every interaction **smarter, faster, and more personal**. + +## Prerequisites + +Before you begin, make sure you have: + +1. Installed the dependencies: +```bash +pip install langchain mem0ai langchain-tavily langchain-openai +``` + +2. Set up your API keys in a .env file: +```bash +OPENAI_API_KEY=your-openai-key +TAVILY_API_KEY=your-tavily-key +MEM0_API_KEY=your-mem0-key +``` + +## Code Walkthrough +Let’s break down the main components. + +### 1: Initialize Mem0 with Custom Instructions + +We configure Mem0 with custom instructions that guide it to infer user memories tailored specifically for our usecase. + +```python +from mem0 import MemoryClient + +mem0_client = MemoryClient() + +mem0_client.project.update( + custom_instructions=''' +INFER THE MEMORIES FROM USER QUERIES EVEN IF IT'S A QUESTION. + +We are building personalized search for which we need to understand about user's preferences and life +and extract facts and memories accordingly. +''' +) +``` +Now, if a user casually mentions "I need to pick up my daughter", or "What's the weather at Los Angeles", Mem0 remembers they have a daughter or user is somewhat interested/connected with Los Angeles in terms of location, those will be referred for future searches. + +### 2. Simulating User History +To test personalization, we preload some sample conversation history for a user: + +```python +def setup_user_history(user_id): + conversations = [ + [{"role": "user", "content": "What will be the weather today at Los Angeles? I need to pick up my daughter from office."}, + {"role": "assistant", "content": "I'll check the weather in LA for you."}], + [{"role": "user", "content": "I'm looking for vegan restaurants in Santa Monica"}, + {"role": "assistant", "content": "I'll find great vegan options in Santa Monica."}], + [{"role": "user", "content": "My 7-year-old daughter is allergic to peanuts"}, + {"role": "assistant", "content": "I'll remember to check for peanut-free options."}], + [{"role": "user", "content": "I work remotely and need coffee shops with good wifi"}, + {"role": "assistant", "content": "I'll find remote-work-friendly coffee shops."}], + [{"role": "user", "content": "We love hiking and outdoor activities on weekends"}, + {"role": "assistant", "content": "Great! I'll keep your outdoor activity preferences in mind."}], + ] + + for conversation in conversations: + mem0_client.add(conversation, user_id=user_id, output_format="v1.1") +``` +This gives the agent a baseline understanding of the user’s lifestyle and needs. + +### 3. Retrieving User Context from Memory +When a user makes a new search query, we retrieve relevant memories to enhance the search query: + +```python +def get_user_context(user_id, query): + filters = {"AND": [{"user_id": user_id}]} + user_memories = mem0_client.search(query=query, version="v2", filters=filters) + + if user_memories: + context = "\n".join([f"- {memory['memory']}" for memory in user_memories]) + return context + else: + return "No previous user context available." +``` +This context is injected into the search agent so results are personalized. + +### 4. Creating the Personalized Search Agent +The agent uses Tavily search, but always augments search queries with user context: + +```python +def create_personalized_search_agent(user_context): + tavily_search = TavilySearch( + max_results=10, + search_depth="advanced", + include_answer=True, + topic="general" + ) + + tools = [tavily_search] + + prompt = ChatPromptTemplate.from_messages([ + ("system", f"""You are a personalized search assistant. + +USER CONTEXT AND PREFERENCES: +{user_context} + +YOUR ROLE: +1. Analyze the user's query and context. +2. Enhance the query with relevant personal memories. +3. Always use tavily_search for results. +4. Explain which memories influenced personalization. +"""), + MessagesPlaceholder(variable_name="messages"), + MessagesPlaceholder(variable_name="agent_scratchpad"), + ]) + + agent = create_openai_tools_agent(llm=llm, tools=tools, prompt=prompt) + return AgentExecutor(agent=agent, tools=tools, verbose=True, return_intermediate_steps=True) +``` + +### 5. Run a Personalized Search +The workflow ties everything together: + +```python +def conduct_personalized_search(user_id, query): + user_context = get_user_context(user_id, query) + agent_executor = create_personalized_search_agent(user_context) + + response = agent_executor.invoke({"messages": [HumanMessage(content=query)]}) + return {"agent_response": response['output']} +``` + +### 6. Store New Interactions +Every new query/response pair is stored for future personalization: + +```python +def store_search_interaction(user_id, original_query, agent_response): + interaction = [ + {"role": "user", "content": f"Searched for: {original_query}"}, + {"role": "assistant", "content": f"Results based on preferences: {agent_response}"} + ] + mem0_client.add(messages=interaction, user_id=user_id, output_format="v1.1") +``` + +### Full Example Run + +```python +if __name__ == "__main__": + user_id = "john" + setup_user_history(user_id) + + queries = [ + "good coffee shops nearby for working", + "what can I make for my kid in lunch?" + ] + + for q in queries: + results = conduct_personalized_search(user_id, q) + print(f"\nQuery: {q}") + print(f"Personalized Response: {results['agent_response']}") +``` + +## How It Works in Practice +Here’s how personalization plays out: + +- Context Gathering: User previously mentioned living in Los Angeles, being vegan, and having a 7-year-old daughter allergic to peanuts. +- Enhanced Search Query: +Query -> "good coffee shops nearby for working" +Enhanced Query -> "good coffee shops in Los Angeles with strong wifi, remote-work-friendly" +- Personalized Results: The assistant only returns wifi-friendly, work-friendly cafes near Los Angeles. +- Memory Update: Interaction is saved for better future recommendations. + +## Conclusion +With Mem0 + Tavily, you can build a search assistant that doesn’t just fetch results but it understands the person behind the query. + +Whether for shopping, travel, or daily life, this approach turns a generic search into a truly personalized experience. + +Full Code: [Personalized Search GitHub](https://github.com/mem0ai/mem0/blob/main/examples/misc/personalized_search.py) \ No newline at end of file diff --git a/docs/v0x/examples/youtube-assistant.mdx b/docs/v0x/examples/youtube-assistant.mdx new file mode 100644 index 000000000..ffea6fd68 --- /dev/null +++ b/docs/v0x/examples/youtube-assistant.mdx @@ -0,0 +1,56 @@ +--- +title: YouTube Assistant Extension +--- + +Enhance your YouTube experience with Mem0's **YouTube Assistant**, a Chrome extension that brings AI-powered chat directly to your YouTube videos. Get instant, personalized answers about video content while leveraging your own knowledge and memories - all without leaving the page. + +## Features + +- **Contextual AI Chat**: Ask questions about videos you're watching +- **Seamless Integration**: Chat interface sits alongside YouTube's native UI +- **Memory Integration**: Personalized responses based on your knowledge through Mem0 +- **Real-Time Memory**: Memories are updated in real-time based on your interactions + +## Demo Video + + + +## Installation + +This extension is not available on the Chrome Web Store yet. You can install it manually using below method: + +### Manual Installation (Developer Mode) + +1. **Download the Extension**: Clone or download the extension files from the [Mem0 GitHub repository](https://github.com/mem0ai/mem0/tree/main/examples). +2. **Build**: Run `npm install` followed by `npm run build` to install the dependencies and build the extension. +3. **Access Chrome Extensions**: Open Google Chrome and navigate to `chrome://extensions`. +4. **Enable Developer Mode**: Toggle the "Developer mode" switch in the top right corner. +5. **Load Unpacked Extension**: Click "Load unpacked" and select the directory containing the extension files. +6. **Confirm Installation**: The Mem0 YouTube Assistant Extension should now appear in your Chrome toolbar. + +## Setup + +1. **Configure API Settings**: Click the extension icon and enter your OpenAI API key (required to use the extension) +2. **Customize Settings**: Configure additional settings such as model, temperature, and memory settings +3. **Navigate to YouTube**: Start using the assistant on any YouTube video +4. **Memories**: Enter your Mem0 API key to enable personalized responses, and feed initial memories from settings + +## Example Prompts + +- "Can you summarize the main points of this video?" +- "Explain the concept they just mentioned" +- "How does this relate to what I already know?" +- "What are some practical applications of this topic related to my work?" + + +## Privacy and Data Security + +Your API keys are stored locally in your browser. Your messages are sent to the Mem0 API for extracting and retrieving memories. Mem0 is committed to ensuring your data's privacy and security. diff --git a/docs/v0x/faqs.mdx b/docs/v0x/faqs.mdx new file mode 100644 index 000000000..97df10832 --- /dev/null +++ b/docs/v0x/faqs.mdx @@ -0,0 +1,267 @@ +--- +title: FAQs (v0.x) +description: 'Frequently asked questions about Mem0 v0.x' +icon: "question" +iconType: "solid" +--- + + +**This is legacy documentation for Mem0 v0.x.** For the latest FAQs, please refer to [v1.0 Beta FAQs](/faqs). + + +## General Questions + +### What is Mem0 v0.x? + +Mem0 v0.x is the legacy version of Mem0's memory layer for LLMs. While still functional, it lacks the advanced features and optimizations available in v1.0 Beta. + +### Should I upgrade to v1.0 Beta? + +Yes! v1.0 Beta offers significant improvements: +- Enhanced filtering with logical operators +- Reranking support for better search relevance +- Improved async performance +- Standardized API responses +- Better error handling + +See our [migration guide](/migration/v0-to-v1) for upgrade instructions. + +### Is v0.x still supported? + +v0.x receives minimal maintenance but no new features. We recommend upgrading to v1.0 Beta for the latest improvements and active support. + +## API Questions + +### Why do I get different response formats? + +In v0.x, response format depends on the `output_format` parameter: + +```python +# v1.0 format (list) +result = m.add("memory", user_id="alice", output_format="v1.0") +# Returns: [{"id": "...", "memory": "...", "event": "ADD"}] + +# v1.1 format (dict) +result = m.add("memory", user_id="alice", output_format="v1.1") +# Returns: {"results": [{"id": "...", "memory": "...", "event": "ADD"}]} +``` + +**Solution:** Always use `output_format="v1.1"` for consistency. + +### How do I handle both response formats? + +```python +def normalize_response(result): + """Normalize v0.x response formats""" + if isinstance(result, list): + return {"results": result} + return result + +# Usage +result = m.add("memory", user_id="alice") +normalized = normalize_response(result) +for memory in normalized["results"]: + print(memory["memory"]) +``` + +### Can I use async in v0.x? + +Yes, but it's optional and less optimized: + +```python +# Optional async mode +result = m.add("memory", user_id="alice", async_mode=True) + +# Or use AsyncMemory +from mem0 import AsyncMemory +async_m = AsyncMemory() +result = await async_m.add("memory", user_id="alice") +``` + +## Configuration Questions + +### What vector stores work with v0.x? + +v0.x supports most vector stores: +- Qdrant +- Chroma +- Pinecone +- Weaviate +- PGVector +- And others + +### How do I configure LLMs in v0.x? + +```python +config = { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-3.5-turbo", + "api_key": "your-api-key" + } + }, + "version": "v1.0" # Supported in v0.x +} + +m = Memory.from_config(config) +``` + +### Can I use custom prompts in v0.x? + +Limited support: + +```python +config = { + "custom_fact_extraction_prompt": "Your custom prompt here" + # custom_update_memory_prompt not available in v0.x +} +``` + +## Migration Questions + +### Is migration difficult? + +No! Most changes are simple parameter removals: + +```python +# Before (v0.x) +result = m.add("memory", user_id="alice", output_format="v1.1", version="v1.0") + +# After (v1.0 Beta) +result = m.add("memory", user_id="alice") +``` + +### Will I lose my data? + +No! Your existing memories remain fully compatible with v1.0 Beta. + +### Do I need to re-index my vectors? + +No! Existing vector data works with v1.0 Beta without changes. + +### Can I rollback if needed? + +Yes! You can always rollback: + +```bash +pip install mem0ai==0.1.20 # Last stable v0.x +``` + +## Feature Questions + +### Does v0.x support reranking? + +No, reranking is only available in v1.0 Beta: + +```python +# v1.0 Beta only +results = m.search("query", user_id="alice", rerank=True) +``` + +### Can I use advanced filtering in v0.x? + +No, only basic key-value filtering: + +```python +# v0.x - basic only +filters = {"category": "food", "user_id": "alice"} + +# v1.0 Beta - advanced operators +filters = { + "AND": [ + {"category": "food"}, + {"score": {"gte": 0.8}} + ] +} +``` + +### Does v0.x support metadata filtering? + +Yes, but basic: + +```python +# Basic metadata filtering +results = m.search( + "query", + user_id="alice", + filters={"category": "work"} +) +``` + +## Performance Questions + +### Is v0.x slower than v1.0 Beta? + +Yes, v1.0 Beta includes several performance optimizations: +- Better async handling +- Optimized vector operations +- Improved memory management + +### How do I optimize v0.x performance? + +1. Use async mode when possible +2. Configure appropriate vector store settings +3. Use efficient metadata filters +4. Consider upgrading to v1.0 Beta + +### Can I batch operations in v0.x? + +Limited support. Better batch processing available in v1.0 Beta. + +## Troubleshooting + +### Common v0.x Issues + +#### 1. Inconsistent Response Formats +**Problem:** Getting different response types +**Solution:** Always use `output_format="v1.1"` + +#### 2. Async Mode Not Working +**Problem:** Async operations failing +**Solution:** Use `AsyncMemory` class or `async_mode=True` + +#### 3. Configuration Errors +**Problem:** Config not loading properly +**Solution:** Check version parameter and config structure + +### Error Messages + +#### "Invalid output format" +```python +# Fix: Use supported format +result = m.add("memory", user_id="alice", output_format="v1.1") +``` + +#### "Version not supported" +```python +# Fix: Use supported version +config = {"version": "v1.0"} # Supported in v0.x +``` + +#### "Async mode not available" +```python +# Fix: Use AsyncMemory +from mem0 import AsyncMemory +async_m = AsyncMemory() +``` + +## Getting Help + +### Documentation +- [v0.x Quickstart](/v0x/quickstart) +- [Migration Guide](/migration/v0-to-v1) +- [v1.0 Beta Docs](/) + +### Community +- [GitHub Discussions](https://github.com/mem0ai/mem0/discussions) +- [Discord Community](https://discord.gg/mem0) + +### Migration Support +- [Step-by-step Migration](/migration/v0-to-v1) +- [Breaking Changes](/migration/breaking-changes) +- [API Changes](/migration/api-changes) + + +**Ready to upgrade?** Check out our [migration guide](/migration/v0-to-v1) to move to v1.0 Beta and access the latest features! + \ No newline at end of file diff --git a/docs/v0x/images/add_architecture.png b/docs/v0x/images/add_architecture.png new file mode 100644 index 0000000000000000000000000000000000000000..39792f34a74052315449d814ea4dc6497ed8e667 GIT binary patch literal 282700 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 z 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 ^3Hx|G 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 literal 0 HcmV?d00001 diff --git a/docs/v0x/images/search_architecture.png b/docs/v0x/images/search_architecture.png new file mode 100644 index 0000000000000000000000000000000000000000..1f4f5361cd0a2e9d6abe43592de92e1c5551d1c5 GIT binary patch literal 232226 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 literal 0 HcmV?d00001 diff --git a/docs/v0x/integrations/agentops.mdx b/docs/v0x/integrations/agentops.mdx new file mode 100644 index 000000000..ba25c4057 --- /dev/null +++ b/docs/v0x/integrations/agentops.mdx @@ -0,0 +1,173 @@ +--- +title: AgentOps +--- + +Integrate [**Mem0**](https://github.com/mem0ai/mem0) with [AgentOps](https://agentops.ai), a comprehensive monitoring and analytics platform for AI agents. This integration enables automatic tracking and analysis of memory operations, providing insights into agent performance and memory usage patterns. + +## Overview + +1. Automatic monitoring of Mem0 operations and performance metrics +2. Real-time tracking of memory add, search, and retrieval operations +3. Analytics dashboard with memory usage patterns and insights +4. Error tracking and debugging capabilities for memory operations + +## Prerequisites + +Before setting up Mem0 with AgentOps, ensure you have: + +1. Installed the required packages: +```bash +pip install mem0ai agentops python-dotenv +``` + +2. Valid API keys: + - [AgentOps API Key](https://app.agentops.ai/dashboard/api-keys) + - OpenAI API Key (for LLM operations) + - [Mem0 API Key](https://app.mem0.ai/dashboard/api-keys) (optional, for cloud operations) + +## Basic Integration Example + +The following example demonstrates how to integrate Mem0 with AgentOps monitoring for comprehensive memory operation tracking: + +```python +#Import the required libraries for local memory management with Mem0 +from mem0 import Memory, AsyncMemory +import os +import asyncio +import logging +from dotenv import load_dotenv +import agentops +import openai + +load_dotenv() +#Set up environment variables for API keys +os.environ["AGENTOPS_API_KEY"] = os.getenv("AGENTOPS_API_KEY") +os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY") + +#Set up the configuration for local memory storage and define sample user data. +local_config = { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4o-mini", + "temperature": 0.1, + "max_tokens": 2000, + }, + } +} +user_id = "alice_demo" +agent_id = "assistant_demo" +run_id = "session_001" + +sample_messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + { + "role": "assistant", + "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future.", + }, +] + +sample_preferences = [ + "I prefer dark roast coffee over light roast", + "I exercise every morning at 6 AM", + "I'm vegetarian and avoid all meat products", + "I love reading science fiction novels", + "I work in software engineering", +] + +#This function demonstrates sequential memory operations using the synchronous Memory class +def demonstrate_sync_memory(local_config, sample_messages, sample_preferences, user_id): + """ + Demonstrate synchronous Memory class operations. + """ + + agentops.start_trace("mem0_memory_example", tags=["mem0_memory_example"]) + try: + + memory = Memory.from_config(local_config) + + result = memory.add( + sample_messages, user_id=user_id, metadata={"category": "movie_preferences", "session": "demo"} + ) + + for i, preference in enumerate(sample_preferences): + result = memory.add(preference, user_id=user_id, metadata={"type": "preference", "index": i}) + + search_queries = [ + "What movies does the user like?", + "What are the user's food preferences?", + "When does the user exercise?", + ] + + for query in search_queries: + results = memory.search(query, user_id=user_id) + + if results and "results" in results: + for j, result in enumerate(results['results']): + print(f"Result {j+1}: {result.get('memory', 'N/A')}") + else: + print("No results found") + + all_memories = memory.get_all(user_id=user_id) + if all_memories and "results" in all_memories: + print(f"Total memories: {len(all_memories['results'])}") + + delete_all_result = memory.delete_all(user_id=user_id) + print(f"Delete all result: {delete_all_result}") + + agentops.end_trace(end_state="success") + except Exception as e: + agentops.end_trace(end_state="error") + +# Execute sync demonstrations +demonstrate_sync_memory(local_config, sample_messages, sample_preferences, user_id) + +``` + +For detailed information on this integration, refer to the official [Agentops Mem0 integration documentation](https://docs.agentops.ai/v2/integrations/mem0). + + +## Key Features + +### 1. Automatic Operation Tracking + +AgentOps automatically monitors all Mem0 operations: + +- **Memory Operations**: Track add, search, get_all, delete operations and much more +- **Performance Metrics**: Monitor response times and success rates +- **Error Tracking**: Capture and analyze operation failures + +### 2. Real-time Analytics Dashboard + +Access comprehensive analytics through the AgentOps dashboard: + +- **Usage Patterns**: Visualize memory usage trends over time +- **User Behavior**: Analyze how different users interact with memory +- **Performance Insights**: Identify bottlenecks and optimization opportunities + +### 3. Session Management + +Organize your monitoring with structured sessions: + +- **Session Tracking**: Group related operations into logical sessions +- **Success/Failure Rates**: Track session outcomes for reliability monitoring +- **Custom Metadata**: Add context to sessions for better analysis + +## Best Practices + +1. **Initialize Early**: Always initialize AgentOps before importing Mem0 classes +2. **Session Management**: Use meaningful session names and end sessions appropriately +3. **Error Handling**: Wrap operations in try-catch blocks and report failures +4. **Tagging**: Use tags to organize different types of memory operations +5. **Environment Separation**: Use different projects or tags for dev/staging/prod + +## Help & Resources + +- [AgentOps Documentation](https://docs.agentops.ai/) +- [AgentOps Dashboard](https://app.agentops.ai/) +- [Mem0 Platform](https://app.mem0.ai/) + + + \ No newline at end of file diff --git a/docs/v0x/integrations/agno.mdx b/docs/v0x/integrations/agno.mdx new file mode 100644 index 000000000..f04c69aa4 --- /dev/null +++ b/docs/v0x/integrations/agno.mdx @@ -0,0 +1,203 @@ +--- +title: Agno +--- + +This integration of [**Mem0**](https://github.com/mem0ai/mem0) with [Agno](https://github.com/agno-agi/agno, enables persistent, multimodal memory for Agno-based agents - improving personalization, context awareness, and continuity across conversations. + +## Overview + +1. Store and retrieve memories from Mem0 within Agno agents +2. Support for multimodal interactions (text and images) +3. Semantic search for relevant past conversations +4. Personalized responses based on user history +5. One-line memory integration via `Mem0Tools` + +## Prerequisites + +Before setting up Mem0 with Agno, ensure you have: + +1. Installed the required packages: +```bash +pip install agno mem0ai python-dotenv +``` + +2. Valid API keys: + - [Mem0 API Key](https://app.mem0.ai/dashboard/api-keys) + - OpenAI API Key (for the agent model) + +## Quick Integration (Using `Mem0Tools`) + +The simplest way to integrate Mem0 with Agno Agents is to use Mem0 as a tool using built-in `Mem0Tools`: + +```python +from agno.agent import Agent +from agno.models.openai import OpenAIChat +from agno.tools.mem0 import Mem0Tools + +agent = Agent( + name="Memory Agent", + model=OpenAIChat(id="gpt-4o-mini"), + tools=[Mem0Tools()], + description="An assistant that remembers and personalizes using Mem0 memory." +) +``` + +This enables memory functionality out of the box: + +- **Persistent memory writing**: `Mem0Tools` uses `MemoryClient.add(...)` to store messages from user-agent interactions, including optional metadata such as user ID or session. +- **Contextual memory search**: Compatible queries use `MemoryClient.search(...)` to retrieve relevant past messages, improving contextual understanding. +- **Multimodal support**: Both text and image inputs are supported, allowing richer memory records. + +> `Mem0Tools` uses the `MemoryClient` under the hood and requires no additional setup. You can customize its behavior by modifying your tools list or extending it in code. + +## Full Manual Example + +> Note: Mem0 can also be used with Agno Agents as a separate memory layer. + +The following example demonstrates how to create an Agno agent with Mem0 memory integration, including support for image processing: + +```python +import base64 +from pathlib import Path +from typing import Optional + +from agno.agent import Agent +from agno.media import Image +from agno.models.openai import OpenAIChat +from mem0 import MemoryClient + +# Initialize the Mem0 client +client = MemoryClient() + +# Define the agent +agent = Agent( + name="Personal Agent", + model=OpenAIChat(id="gpt-4"), + description="You are a helpful personal agent that helps me with day to day activities." + "You can process both text and images.", + markdown=True +) + + +def chat_user( + user_input: Optional[str] = None, + user_id: str = "alex", + image_path: Optional[str] = None +) -> str: + """ + Handle user input with memory integration, supporting both text and images. + + Args: + user_input: The user's text input + user_id: Unique identifier for the user + image_path: Path to an image file if provided + + Returns: + The agent's response as a string + """ + if image_path: + # Convert image to base64 + with open(image_path, "rb") as image_file: + base64_image = base64.b64encode(image_file.read()).decode("utf-8") + + # Create message objects for text and image + messages = [] + + if user_input: + messages.append({ + "role": "user", + "content": user_input + }) + + messages.append({ + "role": "user", + "content": { + "type": "image_url", + "image_url": { + "url": f"data:image/jpeg;base64,{base64_image}" + } + } + }) + + # Store messages in memory + client.add(messages, user_id=user_id, output_format='v1.1') + print("✅ Image and text stored in memory.") + + if user_input: + # Search for relevant memories + memories = client.search(user_input, user_id=user_id, output_format='v1.1') + memory_context = "\n".join(f"- {m['memory']}" for m in memories['results']) + + # Construct the prompt + prompt = f""" +You are a helpful personal assistant who helps users with their day-to-day activities and keeps track of everything. + +Your task is to: +1. Analyze the given image (if present) and extract meaningful details to answer the user's question. +2. Use your past memory of the user to personalize your answer. +3. Combine the image content and memory to generate a helpful, context-aware response. + +Here is what I remember about the user: +{memory_context} + +User question: +{user_input} +""" + # Get response from agent + if image_path: + response = agent.run(prompt, images=[Image(filepath=Path(image_path))]) + else: + response = agent.run(prompt) + + # Store the interaction in memory + interaction_message = [{"role": "user", "content": f"User: {user_input}\nAssistant: {response.content}"}] + client.add(interaction_message, user_id=user_id, output_format='v1.1') + return response.content + + return "No user input or image provided." + + +# Example Usage +if __name__ == "__main__": + response = chat_user( + "I like to travel and my favorite destination is London", + image_path="travel_items.jpeg", + user_id="alex" + ) + print(response) +``` + +## Key Features + +### 1. Multimodal Memory Storage + +The integration supports storing both text and image data: + +- **Text Storage**: Conversation history is saved in a structured format +- **Image Analysis**: Agents can analyze images and store visual information +- **Combined Context**: Memory retrieval combines both text and visual data + +### 2. Personalized Agent Responses + +Improve your agent's context awareness: + +- **Memory Retrieval**: Semantic search finds relevant past interactions +- **User Preferences**: Personalize responses based on stored user information +- **Continuity**: Maintain conversation threads across multiple sessions + +### 3. Flexible Configuration + +Customize the integration to your needs: + +- **Use `Mem0Tools()`** for drop-in memory support +- **Use `MemoryClient` directly** for advanced control +- **User Identification**: Organize memories by user ID +- **Memory Search**: Configure search relevance and result count +- **Memory Formatting**: Support for various OpenAI message formats + +## Help & Resources + +- [Agno Documentation](https://docs.agno.com/introduction) +- [Mem0 Platform](https://app.mem0.ai/) + + diff --git a/docs/v0x/integrations/autogen.mdx b/docs/v0x/integrations/autogen.mdx new file mode 100644 index 000000000..5fc38fc7b --- /dev/null +++ b/docs/v0x/integrations/autogen.mdx @@ -0,0 +1,138 @@ +--- +title: AutoGen +--- + +Build conversational AI agents with memory capabilities. This integration combines AutoGen for creating AI agents with Mem0 for memory management, enabling context-aware and personalized interactions. + +## Overview + +In this guide, we'll explore an example of creating a conversational AI system with memory: +- A customer service bot that can recall previous interactions and provide personalized responses. + +## Setup and Configuration + +Install necessary libraries: + +```bash +pip install autogen mem0ai openai python-dotenv +``` + +First, we'll import the necessary libraries and set up our configurations. + +Remember to get the Mem0 API key from [Mem0 Platform](https://app.mem0.ai). + +```python +import os +from autogen import ConversableAgent +from mem0 import MemoryClient +from openai import OpenAI +from dotenv import load_dotenv + +load_dotenv() + +# Configuration +# OPENAI_API_KEY = 'sk-xxx' # Replace with your actual OpenAI API key +# MEM0_API_KEY = 'your-mem0-key' # Replace with your actual Mem0 API key from https://app.mem0.ai +USER_ID = "alice" + +# Set up OpenAI API key +OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY') +# os.environ['MEM0_API_KEY'] = MEM0_API_KEY + +# Initialize Mem0 and AutoGen agents +memory_client = MemoryClient() +agent = ConversableAgent( + "chatbot", + llm_config={"config_list": [{"model": "gpt-4", "api_key": OPENAI_API_KEY}]}, + code_execution_config=False, + human_input_mode="NEVER", +) +``` + +## Storing Conversations in Memory + +Add conversation history to Mem0 for future reference: + +```python +conversation = [ + {"role": "assistant", "content": "Hi, I'm Best Buy's chatbot! How can I help you?"}, + {"role": "user", "content": "I'm seeing horizontal lines on my TV."}, + {"role": "assistant", "content": "I'm sorry to hear that. Can you provide your TV model?"}, + {"role": "user", "content": "It's a Sony - 77\" Class BRAVIA XR A80K OLED 4K UHD Smart Google TV"}, + {"role": "assistant", "content": "Thank you for the information. Let's troubleshoot this issue..."} +] + +memory_client.add(messages=conversation, user_id=USER_ID, output_format="v1.1") +print("Conversation added to memory.") +``` + +## Retrieving and Using Memory + +Create a function to get context-aware responses based on user's question and previous interactions: + +```python +def get_context_aware_response(question): + relevant_memories = memory_client.search(question, user_id=USER_ID, output_format='v1.1') + context = "\n".join([m["memory"] for m in relevant_memories.get('results', [])]) + + prompt = f"""Answer the user question considering the previous interactions: + Previous interactions: + {context} + + Question: {question} + """ + + reply = agent.generate_reply(messages=[{"content": prompt, "role": "user"}]) + return reply + +# Example usage +question = "What was the issue with my TV?" +answer = get_context_aware_response(question) +print("Context-aware answer:", answer) +``` + +## Multi-Agent Conversation + +For more complex scenarios, you can create multiple agents: + +```python +manager = ConversableAgent( + "manager", + system_message="You are a manager who helps in resolving complex customer issues.", + llm_config={"config_list": [{"model": "gpt-4", "api_key": OPENAI_API_KEY}]}, + human_input_mode="NEVER" +) + +def escalate_to_manager(question): + relevant_memories = memory_client.search(question, user_id=USER_ID, output_format='v1.1') + context = "\n".join([m["memory"] for m in relevant_memories.get('results', [])]) + + prompt = f""" + Context from previous interactions: + {context} + + Customer question: {question} + + As a manager, how would you address this issue? + """ + + manager_response = manager.generate_reply(messages=[{"content": prompt, "role": "user"}]) + return manager_response + +# Example usage +complex_question = "I'm not satisfied with the troubleshooting steps. What else can be done?" +manager_answer = escalate_to_manager(complex_question) +print("Manager's response:", manager_answer) +``` + +## Conclusion + +By integrating AutoGen with Mem0, you've created a conversational AI system with memory capabilities. This example demonstrates a customer service bot that can recall previous interactions and provide context-aware responses, with the ability to escalate complex issues to a manager agent. + +This integration enables the creation of more intelligent and personalized AI agents for various applications, such as customer support, virtual assistants, and interactive chatbots. + +## Help + +In case of any questions, please feel free to reach out to us using one of the following methods: + + diff --git a/docs/v0x/integrations/aws-bedrock.mdx b/docs/v0x/integrations/aws-bedrock.mdx new file mode 100644 index 000000000..4c6b9bec7 --- /dev/null +++ b/docs/v0x/integrations/aws-bedrock.mdx @@ -0,0 +1,130 @@ +--- +title: AWS Bedrock +--- + +This integration demonstrates how to use **Mem0** with **AWS Bedrock** and **Amazon OpenSearch Service (AOSS)** to enable persistent, semantic memory in intelligent agents. + +## Overview + +In this guide, you'll: + +1. Configure AWS credentials to enable Bedrock and OpenSearch access +2. Set up the Mem0 SDK to use Bedrock for embeddings and LLM +3. Store and retrieve memories using OpenSearch as a vector store +4. Build memory-aware applications with scalable cloud infrastructure + +## Prerequisites + +- AWS account with access to: + - Bedrock foundation models (e.g., Titan, Claude) + - OpenSearch Service with a configured domain +- Python 3.8+ +- Valid AWS credentials (via environment or IAM role) + +## Setup and Installation + +Install required packages: + +```bash +pip install mem0ai boto3 opensearch-py +``` + +Set environment variables: + +Be sure to configure your AWS credentials using environment variables, IAM roles, or the AWS CLI. + +```python +import os + +os.environ['AWS_REGION'] = 'us-west-2' +os.environ['AWS_ACCESS_KEY_ID'] = 'AKIA...' +os.environ['AWS_SECRET_ACCESS_KEY'] = 'AS...' +``` + +## Initialize Mem0 Integration + +Import necessary modules and configure Mem0: + +```python +import boto3 +from opensearchpy import OpenSearch, RequestsHttpConnection, AWSV4SignerAuth +from mem0.memory.main import Memory + +region = 'us-west-2' +service = 'aoss' +credentials = boto3.Session().get_credentials() +auth = AWSV4SignerAuth(credentials, region, service) + +config = { + "embedder": { + "provider": "aws_bedrock", + "config": { + "model": "amazon.titan-embed-text-v2:0" + } + }, + "llm": { + "provider": "aws_bedrock", + "config": { + "model": "anthropic.claude-3-5-haiku-20241022-v1:0", + "temperature": 0.1, + "max_tokens": 2000 + } + }, + "vector_store": { + "provider": "opensearch", + "config": { + "collection_name": "mem0", + "host": "your-opensearch-domain.us-west-2.es.amazonaws.com", + "port": 443, + "http_auth": auth, + "embedding_model_dims": 1024, + "connection_class": RequestsHttpConnection, + "pool_maxsize": 20, + "use_ssl": True, + "verify_certs": True + } + } +} + +# Initialize memory system +m = Memory.from_config(config) +``` + +## Memory Operations + +Use Mem0 with your Bedrock-powered LLM and OpenSearch storage backend: + +```python +# Store conversational context +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller?"}, + {"role": "user", "content": "I prefer sci-fi."}, + {"role": "assistant", "content": "Noted! I'll suggest sci-fi movies next time."} +] + +m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"}) + +# Search for memory +relevant = m.search("What kind of movies does Alice like?", user_id="alice") + +# Retrieve all user memories +all_memories = m.get_all(user_id="alice") +``` + +## Key Features + +1. **Serverless Memory Embeddings**: Use Titan or other Bedrock models for fast, cloud-native embeddings +2. **Scalable Vector Search**: Store and retrieve vectorized memories via OpenSearch +3. **Seamless AWS Auth**: Uses AWS IAM or environment variables to securely authenticate +4. **User-specific Memory Spaces**: Memories are isolated per user ID +5. **Persistent Memory Context**: Maintain and recall history across sessions + +## Help + +- [AWS Bedrock Documentation](https://docs.aws.amazon.com/bedrock/) +- [Amazon OpenSearch Service Docs](https://docs.aws.amazon.com/opensearch-service/) +- [Mem0 Platform](https://app.mem0.ai) + + + diff --git a/docs/v0x/integrations/crewai.mdx b/docs/v0x/integrations/crewai.mdx new file mode 100644 index 000000000..3f69fcefc --- /dev/null +++ b/docs/v0x/integrations/crewai.mdx @@ -0,0 +1,168 @@ +--- +title: CrewAI +--- + +Build an AI system that combines CrewAI's agent-based architecture with Mem0's memory capabilities. This integration enables persistent memory across agent interactions and personalized task execution based on user history. + +## Overview + +In this guide, we'll create a CrewAI agent that: +1. Uses CrewAI to manage AI agents and tasks +2. Leverages Mem0 to store and retrieve conversation history +3. Creates personalized experiences based on stored user preferences + +## Setup and Configuration + +Install necessary libraries: + +```bash +pip install crewai crewai-tools mem0ai +``` + +Import required modules and set up configurations: + +Remember to get your API keys from [Mem0 Platform](https://app.mem0.ai), [OpenAI](https://platform.openai.com) and [Serper Dev](https://serper.dev) for search capabilities. + +```python +import os +from mem0 import MemoryClient +from crewai import Agent, Task, Crew, Process +from crewai_tools import SerperDevTool + +# Configuration +os.environ["MEM0_API_KEY"] = "your-mem0-api-key" +os.environ["OPENAI_API_KEY"] = "your-openai-api-key" +os.environ["SERPER_API_KEY"] = "your-serper-api-key" + +# Initialize Mem0 client +client = MemoryClient() +``` + +## Store User Preferences + +Set up initial conversation and preferences storage: + +```python +def store_user_preferences(user_id: str, conversation: list): + """Store user preferences from conversation history""" + client.add(conversation, user_id=user_id) + +# Example conversation storage +messages = [ + { + "role": "user", + "content": "Hi there! I'm planning a vacation and could use some advice.", + }, + { + "role": "assistant", + "content": "Hello! I'd be happy to help with your vacation planning. What kind of destination do you prefer?", + }, + {"role": "user", "content": "I am more of a beach person than a mountain person."}, + { + "role": "assistant", + "content": "That's interesting. Do you like hotels or airbnb?", + }, + {"role": "user", "content": "I like airbnb more."}, +] + +store_user_preferences("crew_user_1", messages) +``` + +## Create CrewAI Agent + +Define an agent with memory capabilities: + +```python +def create_travel_agent(): + """Create a travel planning agent with search capabilities""" + search_tool = SerperDevTool() + + return Agent( + role="Personalized Travel Planner Agent", + goal="Plan personalized travel itineraries", + backstory="""You are a seasoned travel planner, known for your meticulous attention to detail.""", + allow_delegation=False, + memory=True, + tools=[search_tool], + ) +``` + +## Define Tasks + +Create tasks for your agent: + +```python +def create_planning_task(agent, destination: str): + """Create a travel planning task""" + return Task( + description=f"""Find places to live, eat, and visit in {destination}.""", + expected_output=f"A detailed list of places to live, eat, and visit in {destination}.", + agent=agent, + ) +``` + +## Set Up Crew + +Configure the crew with memory integration: + +```python +def setup_crew(agents: list, tasks: list): + """Set up a crew with Mem0 memory integration""" + return Crew( + agents=agents, + tasks=tasks, + process=Process.sequential, + memory=True, + memory_config={ + "provider": "mem0", + "config": {"user_id": "crew_user_1"}, + } + ) +``` + +## Main Execution Function + +Implement the main function to run the travel planning system: + +```python +def plan_trip(destination: str, user_id: str): + # Create agent + travel_agent = create_travel_agent() + + # Create task + planning_task = create_planning_task(travel_agent, destination) + + # Setup crew + crew = setup_crew([travel_agent], [planning_task]) + + # Execute and return results + return crew.kickoff() + +# Example usage +if __name__ == "__main__": + result = plan_trip("San Francisco", "crew_user_1") + print(result) +``` + +## Key Features + +1. **Persistent Memory**: Uses Mem0 to maintain user preferences and conversation history +2. **Agent-Based Architecture**: Leverages CrewAI's agent system for task execution +3. **Search Integration**: Includes SerperDev tool for real-world information retrieval +4. **Personalization**: Utilizes stored preferences for tailored recommendations + +## Benefits + +1. **Persistent Context & Memory**: Maintains user preferences and interaction history across sessions +2. **Flexible & Scalable Design**: Easily extendable with new agents, tasks and capabilities + +## Conclusion + +By combining CrewAI with Mem0, you can create sophisticated AI systems that maintain context and provide personalized experiences while leveraging the power of autonomous agents. + +## Help + +- [CrewAI Documentation](https://docs.crewai.com/) +- [Mem0 Platform](https://app.mem0.ai/) + + diff --git a/docs/v0x/integrations/dify.mdx b/docs/v0x/integrations/dify.mdx new file mode 100644 index 000000000..e08b367bf --- /dev/null +++ b/docs/v0x/integrations/dify.mdx @@ -0,0 +1,34 @@ +--- +title: Dify +--- + +# Integrating Mem0 with Dify AI + +Mem0 brings a robust memory layer to Dify AI, empowering your AI agents with persistent conversation storage and retrieval capabilities. With Mem0, your Dify applications gain the ability to recall past interactions and maintain context, ensuring more natural and insightful conversations. + +--- + +## How to Integrate Mem0 in Your Dify Workflow + +1. **Install the Mem0 Plugin:** + Head to the [Dify Marketplace](https://marketplace.dify.ai/plugins/yevanchen/mem0) and install the Mem0 plugin. This is your first step toward adding intelligent memory to your AI applications. + +2. **Create or Open Your Dify Project:** + Whether you're starting fresh or updating an existing project, simply create or open your Dify workspace. + +3. **Add the Mem0 Plugin to Your Project:** + Within your project, add the Mem0 plugin. This integration connects Mem0’s memory management capabilities directly to your Dify application. + +4. **Configure Your Mem0 Settings:** + Customize Mem0 to suit your needs—set preferences for how conversation history is stored, the search parameters, and any other context-aware features. + +5. **Leverage Mem0 in Your Workflow:** + Use Mem0 to store every conversation turn and retrieve past interactions seamlessly. This integration ensures that your AI agents can refer back to important context, making multi-turn dialogues more effective and user-centric. + +--- + +![Mem0 Dify Integration](/images/dify-mem0-integration.png) + +Enhance your Dify-powered AI with Mem0 and transform your conversational experiences. Start integrating intelligent memory management today and give your agents the context they need to excel! + +[Explore Mem0 on Dify Marketplace](https://marketplace.dify.ai/plugins/yevanchen/mem0) \ No newline at end of file diff --git a/docs/v0x/integrations/elevenlabs.mdx b/docs/v0x/integrations/elevenlabs.mdx new file mode 100644 index 000000000..ede81687b --- /dev/null +++ b/docs/v0x/integrations/elevenlabs.mdx @@ -0,0 +1,454 @@ +--- +title: ElevenLabs +--- + +Create voice-based conversational AI agents with memory capabilities by integrating ElevenLabs and Mem0. This integration enables persistent, context-aware voice interactions that remember past conversations. + +## Overview + +In this guide, we'll build a voice agent that: +1. Uses ElevenLabs Conversational AI for voice interaction +2. Leverages Mem0 to store and retrieve memories from past conversations +3. Provides personalized responses based on user history + +## Setup and Configuration + +Install necessary libraries: + +```bash +pip install elevenlabs mem0ai python-dotenv +``` + +Configure your environment variables: + +You'll need both an ElevenLabs API key and a Mem0 API key to use this integration. + +```bash +# Create a .env file with these variables +AGENT_ID=your-agent-id +USER_ID=unique-user-identifier +ELEVENLABS_API_KEY=your-elevenlabs-api-key +MEM0_API_KEY=your-mem0-api-key +``` + +## Integration Code Breakdown + +Let's break down the implementation into manageable parts: + +### 1. Imports and Environment Setup + +First, we import required libraries and set up the environment: + +```python +import os +import signal +import sys +from mem0 import AsyncMemoryClient + +from elevenlabs.client import ElevenLabs +from elevenlabs.conversational_ai.conversation import Conversation +from elevenlabs.conversational_ai.default_audio_interface import DefaultAudioInterface +from elevenlabs.conversational_ai.conversation import ClientTools +``` + +These imports provide: +- Standard Python libraries for system operations and signal handling +- `AsyncMemoryClient` from Mem0 for memory operations +- ElevenLabs components for voice interaction + +### 2. Environment Variables and Validation + +Next, we validate the required environment variables: + +```python +def main(): + # Required environment variables + AGENT_ID = os.environ.get('AGENT_ID') + USER_ID = os.environ.get('USER_ID') + API_KEY = os.environ.get('ELEVENLABS_API_KEY') + MEM0_API_KEY = os.environ.get('MEM0_API_KEY') + + # Validate required environment variables + if not AGENT_ID: + sys.stderr.write("AGENT_ID environment variable must be set\n") + sys.exit(1) + + if not USER_ID: + sys.stderr.write("USER_ID environment variable must be set\n") + sys.exit(1) + + if not API_KEY: + sys.stderr.write("ELEVENLABS_API_KEY not set, assuming the agent is public\n") + + if not MEM0_API_KEY: + sys.stderr.write("MEM0_API_KEY environment variable must be set\n") + sys.exit(1) + + # Set up Mem0 API key in the environment + os.environ['MEM0_API_KEY'] = MEM0_API_KEY +``` + +This section: +- Retrieves required environment variables +- Performs validation to ensure required variables are present +- Exits the application with an error message if required variables are missing +- Sets the Mem0 API key in the environment for the Mem0 client to use + +### 3. Client Initialization + +Initialize both the ElevenLabs and Mem0 clients: + +```python + # Initialize ElevenLabs client + client = ElevenLabs(api_key=API_KEY) + + # Initialize memory client and tools + client_tools = ClientTools() + mem0_client = AsyncMemoryClient() +``` + +Here we: +- Create an ElevenLabs client with the API key +- Initialize a ClientTools object for registering function tools +- Create an AsyncMemoryClient instance for Mem0 interactions + +### 4. Memory Function Definitions + +Define the two key memory functions that will be registered as tools: + +```python + # Define memory-related functions for the agent + async def add_memories(parameters): + """Add a message to the memory store""" + message = parameters.get("message") + await mem0_client.add( + messages=message, + user_id=USER_ID, + output_format="v1.1", + version="v2" + ) + return "Memory added successfully" + + async def retrieve_memories(parameters): + """Retrieve relevant memories based on the input message""" + message = parameters.get("message") + + # Set up filters to retrieve memories for this specific user + filters = { + "AND": [ + { + "user_id": USER_ID + } + ] + } + + # Search for relevant memories using the message as a query + results = await mem0_client.search( + query=message, + version="v2", + filters=filters + ) + + # Extract and join the memory texts + memories = ' '.join([result["memory"] for result in results.get('results', [])]) + print("[ Memories ]", memories) + + if memories: + return memories + return "No memories found" +``` + +These functions: + +#### `add_memories`: +- Takes a message parameter containing information to remember +- Stores the message in Mem0 using the `add` method +- Associates the memory with the specific USER_ID +- Returns a success message to the agent + +#### `retrieve_memories`: +- Takes a message parameter as the search query +- Sets up filters to only retrieve memories for the current user +- Uses semantic search to find relevant memories +- Joins all retrieved memories into a single text +- Prints retrieved memories to the console for debugging +- Returns the memories or a "No memories found" message if none are found + +### 5. Registering Memory Functions as Tools + +Register the memory functions with the ElevenLabs ClientTools system: + +```python + # Register the memory functions as tools for the agent + client_tools.register("addMemories", add_memories, is_async=True) + client_tools.register("retrieveMemories", retrieve_memories, is_async=True) +``` + +This allows the ElevenLabs agent to: +- Access these functions through function calling +- Wait for asynchronous results (is_async=True) +- Call these functions by name ("addMemories" and "retrieveMemories") + +### 6. Conversation Setup + +Configure the conversation with ElevenLabs: + +```python + # Initialize the conversation + conversation = Conversation( + client, + AGENT_ID, + # Assume auth is required when API_KEY is set + requires_auth=bool(API_KEY), + audio_interface=DefaultAudioInterface(), + client_tools=client_tools, + callback_agent_response=lambda response: print(f"Agent: {response}"), + callback_agent_response_correction=lambda original, corrected: print(f"Agent: {original} -> {corrected}"), + callback_user_transcript=lambda transcript: print(f"User: {transcript}"), + # callback_latency_measurement=lambda latency: print(f"Latency: {latency}ms"), + ) +``` + +This sets up the conversation with: +- The ElevenLabs client and Agent ID +- Authentication requirements based on API key presence +- DefaultAudioInterface for handling audio I/O +- The client_tools with our memory functions +- Callback functions for: + - Displaying agent responses + - Showing corrected responses (when the agent self-corrects) + - Displaying user transcripts for debugging + - (Commented out) Latency measurements + +### 7. Conversation Management + +Start and manage the conversation: + +```python + # Start the conversation + print(f"Starting conversation with user_id: {USER_ID}") + conversation.start_session() + + # Handle Ctrl+C to gracefully end the session + signal.signal(signal.SIGINT, lambda sig, frame: conversation.end_session()) + + # Wait for the conversation to end and get the conversation ID + conversation_id = conversation.wait_for_session_end() + print(f"Conversation ID: {conversation_id}") + + +if __name__ == '__main__': + main() +``` + +This final section: +- Prints a message indicating the conversation has started +- Starts the conversation session +- Sets up a signal handler to gracefully end the session on Ctrl+C +- Waits for the session to end and gets the conversation ID +- Prints the conversation ID for reference + +## Memory Tools Overview + +This integration provides two key memory functions to your conversational AI agent: + +### 1. Adding Memories (`addMemories`) + +The `addMemories` tool allows your agent to store important information during a conversation, including: +- User preferences +- Important facts shared by the user +- Decisions or commitments made during the conversation +- Action items to follow up on + +When the agent identifies information worth remembering, it calls this function to store it in the Mem0 database with the appropriate user ID. + +#### How it works: +1. The agent identifies information that should be remembered +2. It formats the information as a message string +3. It calls the `addMemories` function with this message +4. The function stores the memory in Mem0 linked to the user's ID +5. Later conversations can retrieve this memory + +#### Example usage in agent prompt: +``` +When the user shares important information like preferences or personal details, +use the addMemories function to store this information for future reference. +``` + +### 2. Retrieving Memories (`retrieveMemories`) + +The `retrieveMemories` tool allows your agent to search for and retrieve relevant memories from previous conversations. The agent can: +- Search for context related to the current topic +- Recall user preferences +- Remember previous interactions on similar topics +- Create continuity across multiple sessions + +#### How it works: +1. The agent needs context for the current conversation +2. It calls `retrieveMemories` with the current conversation topic or question +3. The function performs a semantic search in Mem0 +4. Relevant memories are returned to the agent +5. The agent incorporates these memories into its response + +#### Example usage in agent prompt: +``` +At the beginning of each conversation turn, use retrieveMemories to check if we've +discussed this topic before or if the user has shared relevant preferences. +``` + +## Configuring Your ElevenLabs Agent + +To enable your agent to effectively use memory: + +1. Add function calling capabilities to your agent in the ElevenLabs platform: + - Go to your agent settings in the ElevenLabs platform + - Navigate to the "Tools" section + - Enable function calling for your agent + - Add the memory tools as described below + +2. Add the `addMemories` and `retrieveMemories` tools to your agent with these specifications: + +For `addMemories`: +```json +{ + "name": "addMemories", + "description": "Stores important information from the conversation to remember for future interactions", + "parameters": { + "type": "object", + "properties": { + "message": { + "type": "string", + "description": "The important information to remember" + } + }, + "required": ["message"] + } +} +``` + +For `retrieveMemories`: +```json +{ + "name": "retrieveMemories", + "description": "Retrieves relevant information from past conversations", + "parameters": { + "type": "object", + "properties": { + "message": { + "type": "string", + "description": "The query to search for in past memories" + } + }, + "required": ["message"] + } +} +``` + +3. Update your agent's prompt to instruct it to use these memory functions. For example: + +``` +You are a helpful voice assistant that remembers past conversations with the user. + +You have access to memory tools that allow you to remember important information: +- Use retrieveMemories at the beginning of the conversation to recall relevant context from prior conversations +- Use addMemories to store new important information such as: + * User preferences + * Personal details the user shares + * Important decisions made + * Tasks or follow-ups promised to the user + +Before responding to complex questions, always check for relevant memories first. +When the user shares important information, make sure to store it for future reference. +``` + +## Example Conversation Flow + +Here's how a typical conversation with memory might flow: + +1. **User speaks**: "Hi, do you remember my favorite color?" + +2. **Agent retrieves memories**: + ```python + # Agent calls retrieve_memories + memories = retrieve_memories({"message": "user's favorite color"}) + # If found: "The user's favorite color is blue" + ``` + +3. **Agent processes with context**: + - If memories found: Prepares a personalized response + - If no memories: Prepares to ask and store the information + +4. **Agent responds**: + - With memory: "Yes, your favorite color is blue!" + - Without memory: "I don't think you've told me your favorite color before. What is it?" + +5. **User responds**: "It's actually green." + +6. **Agent stores new information**: + ```python + # Agent calls add_memories + add_memories({"message": "The user's favorite color is green"}) + ``` + +7. **Agent confirms**: "Thanks, I'll remember that your favorite color is green." + +## Example Use Cases + +- **Personal Assistant** - Remember user preferences, past requests, and important dates + ``` + User: "What restaurants did I say I liked last time?" + Agent: *retrieves memories* "You mentioned enjoying Bella Italia and The Golden Dragon." + ``` + +- **Customer Support** - Recall previous issues a customer has had + ``` + User: "I'm having that same problem again!" + Agent: *retrieves memories* "Is this related to the login issue you reported last week?" + ``` + +- **Educational AI** - Track student progress and tailor teaching accordingly + ``` + User: "Let's continue our math lesson." + Agent: *retrieves memories* "Last time we were working on quadratic equations. Would you like to continue with that?" + ``` + +- **Healthcare Assistant** - Remember symptoms, medications, and health concerns + ``` + User: "Have I told you about my allergy medication?" + Agent: *retrieves memories* "Yes, you mentioned you're taking Claritin for your pollen allergies." + ``` + +## Troubleshooting + +- **Missing API Keys**: + - Error: "API_KEY environment variable must be set" + - Solution: Ensure all environment variables are set correctly in your .env file or system environment + +- **Connection Issues**: + - Error: "Failed to connect to API" + - Solution: Check your network connection and API key permissions. Verify the API keys are valid and have the necessary permissions. + +- **Empty Memory Results**: + - Symptom: Agent always responds with "No memories found" + - Solution: This is normal for new users. The memory database builds up over time as conversations occur. It's also possible your query isn't semantically similar to stored memories - try different phrasing. + +- **Agent Not Using Memories**: + - Symptom: The agent retrieves memories but doesn't incorporate them in responses + - Solution: Update the agent's prompt to explicitly instruct it to use the retrieved memories in its responses + +## Conclusion + +By integrating ElevenLabs Conversational AI with Mem0, you can create voice agents that maintain context across conversations and provide personalized responses based on user history. This powerful combination enables: + +- More natural, context-aware conversations +- Personalized user experiences that improve over time +- Reduced need for users to repeat information +- Long-term relationship building between users and AI agents + +## Help + +- For more details on ElevenLabs, visit the [ElevenLabs Conversational AI Documentation](https://elevenlabs.io/docs/api-reference/conversational-ai) +- For Mem0 documentation, refer to the [Mem0 Platform](https://app.mem0.ai/) +- If you need further assistance, please feel free to reach out to us through the following methods: + + \ No newline at end of file diff --git a/docs/v0x/integrations/flowise.mdx b/docs/v0x/integrations/flowise.mdx new file mode 100644 index 000000000..9f1d747d9 --- /dev/null +++ b/docs/v0x/integrations/flowise.mdx @@ -0,0 +1,126 @@ +--- +title: Flowise +--- + +The [**Mem0 Memory**](https://github.com/mem0ai/mem0) integration with [Flowise](https://github.com/FlowiseAI/Flowise) enables persistent memory capabilities for your AI chatflows. [Flowise](https://flowiseai.com/) is an open-source low-code tool for developers to build customized LLM orchestration flows & AI agents using a drag & drop interface. + +## Overview + +1. 🧠 Provides persistent memory storage for Flowise chatflows +2. 🔄 Seamless integration with existing Flowise templates +3. 🚀 Compatible with various LLM nodes in Flowise +4. 📝 Supports custom memory configurations +5. ⚡ Easy to set up and manage + +## Prerequisites + +Before setting up Mem0 with Flowise, ensure you have: + +1. [Flowise installed](https://github.com/FlowiseAI/Flowise#⚡quick-start) (NodeJS >= 18.15.0 required): +```bash +npm install -g flowise +npx flowise start +``` + +2. Access to the Flowise UI at http://localhost:3000 +3. Basic familiarity with [Flowise's LLM orchestration](https://flowiseai.com/#features) concepts + +## Setup and Configuration + +### 1. Set Up Flowise + +1. Open the Flowise application and create a new canvas, or select a template from the Flowise marketplace. +2. In this example, we use the **Conversation Chain** template. +3. Replace the default **Buffer Memory** with **Mem0 Memory**. + +![Flowise Memory Integration](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/flowise-flow.png) + +### 2. Obtain Your Mem0 API Key + +1. Navigate to the [Mem0 API Key dashboard](https://app.mem0.ai/dashboard/api-keys). +2. Generate or copy your existing Mem0 API Key. + +![Mem0 API Key](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/api-key.png) + +### 3. Configure Mem0 Credentials + +1. Enter the **Mem0 API Key** in the Mem0 Credentials section. +2. Configure additional settings as needed: + +```typescript +{ + "apiKey": "m0-xxx", + "userId": "user-123", // Optional: Specify user ID + "projectId": "proj-xxx", // Optional: Specify project ID + "orgId": "org-xxx" // Optional: Specify organization ID +} +``` + +

+ Mem0 Credentials +
Configure API Credentials
+
+ +## Memory Features + +### 1. Basic Memory Storage + +Test your memory configuration: + +1. Save your Flowise configuration +2. Run a test chat and store some information +3. Verify the stored memories in the [Mem0 Dashboard](https://app.mem0.ai/dashboard/requests) + +![Flowise Test Chat](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/flowise-chat-1.png) + +### 2. Memory Retention + +Validate memory persistence: + +1. Clear the chat history in Flowise +2. Ask a question about previously stored information +3. Confirm that the AI remembers the context + +![Testing Memory Retention](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/flowise-chat-2.png) + +## Advanced Configuration + +### Memory Settings + +![Mem0 Settings](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/settings.png) + +Available settings include: + +1. **Search Only Mode**: Enable memory retrieval without creating new memories +2. **Mem0 Entities**: Configure identifiers: + - `user_id`: Unique identifier for each user + - `run_id`: Specific conversation session ID + - `app_id`: Application identifier + - `agent_id`: AI agent identifier +3. **Project ID**: Assign memories to specific projects +4. **Organization ID**: Organize memories by organization + +### Platform Configuration + +Additional settings available in [Mem0 Project Settings](https://app.mem0.ai/dashboard/project-settings): + +1. **Custom Instructions**: Define memory extraction rules +2. **Expiration Date**: Set automatic memory cleanup periods + +![Mem0 Project Settings](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/mem0-settings.png) + +## Best Practices + +1. **User Identification**: Use consistent `user_id` values for reliable memory retrieval +2. **Memory Organization**: Utilize projects and organizations for better memory management +3. **Regular Maintenance**: Monitor and clean up unused memories periodically + +## Help & Resources + +- [Flowise Documentation](https://flowiseai.com/docs) +- [Flowise GitHub Repository](https://github.com/FlowiseAI/Flowise) +- [Flowise Website](https://flowiseai.com/) +- [Mem0 Platform](https://app.mem0.ai/) +- Need assistance? Reach out through: + + \ No newline at end of file diff --git a/docs/v0x/integrations/google-ai-adk.mdx b/docs/v0x/integrations/google-ai-adk.mdx new file mode 100644 index 000000000..59e317770 --- /dev/null +++ b/docs/v0x/integrations/google-ai-adk.mdx @@ -0,0 +1,287 @@ +--- +title: Google Agent Development Kit +--- + +Integrate [**Mem0**](https://github.com/mem0ai/mem0) with [Google Agent Development Kit (ADK)](https://github.com/google/adk-python), an open-source framework for building multi-agent workflows. This integration enables agents to access persistent memory across conversations, enhancing context retention and personalization. + +## Overview + +1. Store and retrieve memories from Mem0 within Google ADK agents +2. Multi-agent workflows with shared memory across hierarchies +3. Retrieve relevant memories from past conversations +4. Personalized responses + +## Prerequisites + +Before setting up Mem0 with Google ADK, ensure you have: + +1. Installed the required packages: +```bash +pip install google-adk mem0ai python-dotenv +``` + +2. Valid API keys: + - [Mem0 API Key](https://app.mem0.ai/dashboard/api-keys) + - Google AI Studio API Key + +## Basic Integration Example + +The following example demonstrates how to create a Google ADK agent with Mem0 memory integration: + +```python +import os +import asyncio +from google.adk.agents import Agent +from google.adk.runners import Runner +from google.adk.sessions import InMemorySessionService +from google.genai import types +from mem0 import MemoryClient +from dotenv import load_dotenv + +load_dotenv() + +# Set up environment variables +# os.environ["GOOGLE_API_KEY"] = "your-google-api-key" +# os.environ["MEM0_API_KEY"] = "your-mem0-api-key" + +# Initialize Mem0 client +mem0 = MemoryClient() + +# Define memory function tools +def search_memory(query: str, user_id: str) -> dict: + """Search through past conversations and memories""" + memories = mem0.search(query, user_id=user_id, output_format='v1.1') + if memories.get('results', []): + memory_list = memories['results'] + memory_context = "\n".join([f"- {mem['memory']}" for mem in memory_list]) + return {"status": "success", "memories": memory_context} + return {"status": "no_memories", "message": "No relevant memories found"} + +def save_memory(content: str, user_id: str) -> dict: + """Save important information to memory""" + try: + result = mem0.add([{"role": "user", "content": content}], user_id=user_id, output_format='v1.1') + return {"status": "success", "message": "Information saved to memory", "result": result} + except Exception as e: + return {"status": "error", "message": f"Failed to save memory: {str(e)}"} + +# Create agent with memory capabilities +personal_assistant = Agent( + name="personal_assistant", + model="gemini-2.0-flash", + instruction="""You are a helpful personal assistant with memory capabilities. + Use the search_memory function to recall past conversations and user preferences. + Use the save_memory function to store important information about the user. + Always personalize your responses based on available memory.""", + description="A personal assistant that remembers user preferences and past interactions", + tools=[search_memory, save_memory] +) + +async def chat_with_agent(user_input: str, user_id: str) -> str: + """ + Handle user input with automatic memory integration. + + Args: + user_input: The user's message + user_id: Unique identifier for the user + + Returns: + The agent's response + """ + # Set up session and runner + session_service = InMemorySessionService() + session = await session_service.create_session( + app_name="memory_assistant", + user_id=user_id, + session_id=f"session_{user_id}" + ) + runner = Runner(agent=personal_assistant, app_name="memory_assistant", session_service=session_service) + + # Create content and run agent + content = types.Content(role='user', parts=[types.Part(text=user_input)]) + events = runner.run(user_id=user_id, session_id=session.id, new_message=content) + + # Extract final response + for event in events: + if event.is_final_response(): + response = event.content.parts[0].text + + return response + + return "No response generated" + +# Example usage +if __name__ == "__main__": + response = asyncio.run(chat_with_agent( + "I love Italian food and I'm planning a trip to Rome next month", + user_id="alice" + )) + print(response) +``` + +## Multi-Agent Hierarchy with Shared Memory + +Create specialized agents in a hierarchy that share memory: + +```python +from google.adk.tools.agent_tool import AgentTool + +# Travel specialist agent +travel_agent = Agent( + name="travel_specialist", + model="gemini-2.0-flash", + instruction="""You are a travel planning specialist. Use get_user_context to + understand the user's travel preferences and history before making recommendations. + After providing advice, use store_interaction to save travel-related information.""", + description="Specialist in travel planning and recommendations", + tools=[search_memory, save_memory] +) + +# Health advisor agent +health_agent = Agent( + name="health_advisor", + model="gemini-2.0-flash", + instruction="""You are a health and wellness advisor. Use get_user_context to + understand the user's health goals and dietary preferences. + After providing advice, use store_interaction to save health-related information.""", + description="Specialist in health and wellness advice", + tools=[search_memory, save_memory] +) + +# Coordinator agent that delegates to specialists +coordinator_agent = Agent( + name="coordinator", + model="gemini-2.0-flash", + instruction="""You are a coordinator that delegates requests to specialist agents. + For travel-related questions (trips, hotels, flights, destinations), delegate to the travel specialist. + For health-related questions (fitness, diet, wellness, exercise), delegate to the health advisor. + Use get_user_context to understand the user before delegation.""", + description="Coordinates requests between specialist agents", + tools=[ + AgentTool(agent=travel_agent, skip_summarization=False), + AgentTool(agent=health_agent, skip_summarization=False) + ] +) + +def chat_with_specialists(user_input: str, user_id: str) -> str: + """ + Handle user input with specialist agent delegation and memory. + + Args: + user_input: The user's message + user_id: Unique identifier for the user + + Returns: + The specialist agent's response + """ + session_service = InMemorySessionService() + session = session_service.create_session( + app_name="specialist_system", + user_id=user_id, + session_id=f"session_{user_id}" + ) + runner = Runner(agent=coordinator_agent, app_name="specialist_system", session_service=session_service) + + content = types.Content(role='user', parts=[types.Part(text=user_input)]) + events = runner.run(user_id=user_id, session_id=session.id, new_message=content) + + for event in events: + if event.is_final_response(): + response = event.content.parts[0].text + + # Store the conversation in shared memory + conversation = [ + {"role": "user", "content": user_input}, + {"role": "assistant", "content": response} + ] + mem0.add(conversation, user_id=user_id) + + return response + + return "No response generated" + +# Example usage +response = chat_with_specialists("Plan a healthy meal for my Italy trip", user_id="alice") +print(response) +``` + + + +## Quick Start Chat Interface + +Simple interactive chat with memory and Google ADK: + +```python +def interactive_chat(): + """Interactive chat interface with memory and ADK""" + user_id = input("Enter your user ID: ") or "demo_user" + print(f"Chat started for user: {user_id}") + print("Type 'quit' to exit") + print("=" * 50) + + while True: + user_input = input("\nYou: ") + + if user_input.lower() == 'quit': + print("Goodbye! Your conversation has been saved to memory.") + break + else: + response = chat_with_specialists(user_input, user_id) + print(f"Assistant: {response}") + +if __name__ == "__main__": + interactive_chat() +``` + +## Key Features + +### 1. Memory-Enhanced Function Tools +- **Function Tools**: Standard Python functions that can search and save memories +- **Tool Context**: Access to session state and memory through function parameters +- **Structured Returns**: Dictionary-based returns with status indicators for better LLM understanding + +### 2. Multi-Agent Memory Sharing +- **Agent-as-a-Tool**: Specialists can be called as tools while maintaining shared memory +- **Hierarchical Delegation**: Coordinator agents route to specialists based on context +- **Memory Categories**: Store interactions with metadata for better organization + +### 3. Flexible Memory Operations +- **Search Capabilities**: Retrieve relevant memories through conversation history +- **User Segmentation**: Organize memories by user ID +- **Memory Management**: Built-in tools for saving and retrieving information + +## Configuration Options + +Customize memory behavior and agent setup: + +```python +# Configure memory search with metadata +memories = mem0.search( + query="travel preferences", + user_id="alice", + limit=5, + filters={"category": "travel"} # Filter by category if supported +) + +# Configure agent with custom model settings +agent = Agent( + name="custom_agent", + model="gemini-2.0-flash", # or use LiteLLM for other models + instruction="Custom agent behavior", + tools=[memory_tools], + # Additional ADK configurations +) + +# Use Google Cloud Vertex AI instead of AI Studio +os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "True" +os.environ["GOOGLE_CLOUD_PROJECT"] = "your-project-id" +os.environ["GOOGLE_CLOUD_LOCATION"] = "us-central1" +``` + +## Help + +- [Google ADK Documentation](https://google.github.io/adk-docs/) +- [Mem0 Platform](https://app.mem0.ai/) +- If you need further assistance, please feel free to reach out to us through the following methods: + + \ No newline at end of file diff --git a/docs/v0x/integrations/keywords.mdx b/docs/v0x/integrations/keywords.mdx new file mode 100644 index 000000000..fff71f1ec --- /dev/null +++ b/docs/v0x/integrations/keywords.mdx @@ -0,0 +1,140 @@ +--- +title: Keywords AI +--- + +Build AI applications with persistent memory and comprehensive LLM observability by integrating Mem0 with Keywords AI. + +## Overview + +Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. Keywords AI provides complete LLM observability. + +Combining Mem0 with Keywords AI allows you to: +1. Add persistent memory to your AI applications +2. Track interactions across sessions +3. Monitor memory usage and retrieval with Keywords AI observability +4. Optimize token usage and reduce costs + + +You can get your Mem0 API key, user_id, and org_id from the [Mem0 dashboard](https://app.mem0.ai/). These are required for proper integration. + + +## Setup and Configuration + +Install the necessary libraries: + +```bash +pip install mem0 keywordsai-sdk +``` + +Set up your environment variables: + +```python +import os + +# Set your API keys +os.environ["MEM0_API_KEY"] = "your-mem0-api-key" +os.environ["KEYWORDSAI_API_KEY"] = "your-keywords-api-key" +os.environ["KEYWORDSAI_BASE_URL"] = "https://api.keywordsai.co/api/" +``` + +## Basic Integration Example + +Here's a simple example of using Mem0 with Keywords AI: + +```python +from mem0 import Memory +import os + +# Configuration +api_key = os.getenv("MEM0_API_KEY") +keywordsai_api_key = os.getenv("KEYWORDSAI_API_KEY") +base_url = os.getenv("KEYWORDSAI_BASE_URL") # "https://api.keywordsai.co/api/" + +# Set up Mem0 with Keywords AI as the LLM provider +config = { + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4o-mini", + "temperature": 0.0, + "api_key": keywordsai_api_key, + "openai_base_url": base_url, + }, + } +} + +# Initialize Memory +memory = Memory.from_config(config_dict=config) + +# Add a memory +result = memory.add( + "I like to take long walks on weekends.", + user_id="alice", + metadata={"category": "hobbies"}, +) + +print(result) +``` + +## Advanced Integration with OpenAI SDK + +For more advanced use cases, you can integrate Keywords AI with Mem0 through the OpenAI SDK: + +```python +from openai import OpenAI +import os +import json + +# Initialize client +client = OpenAI( + api_key=os.environ.get("KEYWORDSAI_API_KEY"), + base_url=os.environ.get("KEYWORDSAI_BASE_URL"), +) + +# Sample conversation messages +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] + +# Add memory and generate a response +response = client.chat.completions.create( + model="openai/gpt-4o", + messages=messages, + extra_body={ + "mem0_params": { + "user_id": "test_user", + "org_id": "org_1", + "api_key": os.environ.get("MEM0_API_KEY"), + "add_memories": { + "messages": messages, + }, + } + }, +) + +print(json.dumps(response.model_dump(), indent=4)) +``` + +For detailed information on this integration, refer to the official [Keywords AI Mem0 integration documentation](https://docs.keywordsai.co/integration/development-frameworks/mem0). + +## Key Features + +1. **Memory Integration**: Store and retrieve relevant information from past interactions +2. **LLM Observability**: Track memory usage and retrieval patterns with Keywords AI +3. **Session Persistence**: Maintain context across multiple user sessions +4. **Cost Optimization**: Reduce token usage through efficient memory retrieval + +## Conclusion + +Integrating Mem0 with Keywords AI provides a powerful combination for building AI applications with persistent memory and comprehensive observability. This integration enables more personalized user experiences while providing insights into your application's memory usage. + +## Help + +For more information, refer to: +- [Keywords AI Documentation](https://docs.keywordsai.co) +- [Mem0 Platform](https://app.mem0.ai/) + + diff --git a/docs/v0x/integrations/langchain-tools.mdx b/docs/v0x/integrations/langchain-tools.mdx new file mode 100644 index 000000000..62b3b0d71 --- /dev/null +++ b/docs/v0x/integrations/langchain-tools.mdx @@ -0,0 +1,336 @@ +--- +title: Langchain Tools +description: 'Integrate Mem0 with LangChain tools to enable AI agents to store, search, and manage memories through structured interfaces' +--- + +## Overview + +Mem0 provides a suite of tools for storing, searching, and retrieving memories, enabling agents to maintain context and learn from past interactions. The tools are built as Langchain tools, making them easily integrable with any AI agent implementation. + +## Installation + +Install the required dependencies: + +```bash +pip install langchain_core +pip install mem0ai +``` + +## Authentication + +Import the necessary dependencies and initialize the client: + +```python +from langchain_core.tools import StructuredTool +from mem0 import MemoryClient +from pydantic import BaseModel, Field +from typing import List, Dict, Any, Optional +import os + +os.environ["MEM0_API_KEY"] = "your-api-key" + +client = MemoryClient( + org_id=your_org_id, + project_id=your_project_id +) +``` + +## Available Tools + +Mem0 provides three main tools for memory management: + +### 1. ADD Memory Tool + +The ADD tool allows you to store new memories with associated metadata. It's particularly useful for saving conversation history and user preferences. + +#### Schema + +```python +class Message(BaseModel): + role: str = Field(description="Role of the message sender (user or assistant)") + content: str = Field(description="Content of the message") + +class AddMemoryInput(BaseModel): + messages: List[Message] = Field(description="List of messages to add to memory") + user_id: str = Field(description="ID of the user associated with these messages") + output_format: str = Field(description="Version format for the output") + metadata: Optional[Dict[str, Any]] = Field(description="Additional metadata for the messages", default=None) + + class Config: + json_schema_extra = { + "examples": [{ + "messages": [ + {"role": "user", "content": "Hi, I'm Alex. I'm a vegetarian and I'm allergic to nuts."}, + {"role": "assistant", "content": "Hello Alex! I've noted that you're a vegetarian and have a nut allergy."} + ], + "user_id": "alex", + "output_format": "v1.1", + "metadata": {"food": "vegan"} + }] + } +``` + +#### Implementation + +```python +def add_memory(messages: List[Message], user_id: str, output_format: str, metadata: Optional[Dict[str, Any]] = None) -> Any: + """Add messages to memory with associated user ID and metadata.""" + message_dicts = [msg.dict() for msg in messages] + return client.add(message_dicts, user_id=user_id, output_format=output_format, metadata=metadata) + +add_tool = StructuredTool( + name="add_memory", + description="Add new messages to memory with associated metadata", + func=add_memory, + args_schema=AddMemoryInput +) +``` + +#### Example Usage + + +```python Code +add_input = { + "messages": [ + {"role": "user", "content": "Hi, I'm Alex. I'm a vegetarian and I'm allergic to nuts."}, + {"role": "assistant", "content": "Hello Alex! I've noted that you're a vegetarian and have a nut allergy."} + ], + "user_id": "alex", + "output_format": "v1.1", + "metadata": {"food": "vegan"} +} +add_result = add_tool.invoke(add_input) +``` + +```json Output +{ + "results": [ + { + "memory": "Name is Alex", + "event": "ADD" + }, + { + "memory": "Is a vegetarian", + "event": "ADD" + }, + { + "memory": "Is allergic to nuts", + "event": "ADD" + } + ] +} +``` + + +### 2. SEARCH Memory Tool + +The SEARCH tool enables querying stored memories using natural language queries and advanced filtering options. + +#### Schema + +```python +class SearchMemoryInput(BaseModel): + query: str = Field(description="The search query string") + filters: Dict[str, Any] = Field(description="Filters to apply to the search") + version: str = Field(description="Version of the memory to search") + + class Config: + json_schema_extra = { + "examples": [{ + "query": "tell me about my allergies?", + "filters": { + "AND": [ + {"user_id": "alex"}, + {"created_at": {"gte": "2024-01-01", "lte": "2024-12-31"}} + ] + }, + "version": "v2" + }] + } +``` + +#### Implementation + +```python +def search_memory(query: str, filters: Dict[str, Any], version: str) -> Any: + """Search memory with the given query and filters.""" + return client.search(query=query, version=version, filters=filters) + +search_tool = StructuredTool( + name="search_memory", + description="Search through memories with a query and filters", + func=search_memory, + args_schema=SearchMemoryInput +) +``` + +#### Example Usage + + +```python Code +search_input = { + "query": "what is my name?", + "filters": { + "AND": [ + {"created_at": {"gte": "2024-07-20", "lte": "2024-12-10"}}, + {"user_id": "alex"} + ] + }, + "version": "v2" +} +result = search_tool.invoke(search_input) +``` + +```json Output +[ + { + "id": "1a75e827-7eca-45ea-8c5c-cfd43299f061", + "memory": "Name is Alex", + "user_id": "alex", + "hash": "d0fccc8fa47f7a149ee95750c37bb0ca", + "metadata": { + "food": "vegan" + }, + "categories": [ + "personal_details" + ], + "created_at": "2024-11-27T16:53:43.276872-08:00", + "updated_at": "2024-11-27T16:53:43.276885-08:00", + "score": 0.3810526501504994 + } +] +``` + + +### 3. GET_ALL Memory Tool + +The GET_ALL tool retrieves all memories matching specified criteria, with support for pagination. + +#### Schema + +```python +class GetAllMemoryInput(BaseModel): + version: str = Field(description="Version of the memory to retrieve") + filters: Dict[str, Any] = Field(description="Filters to apply to the retrieval") + page: Optional[int] = Field(description="Page number for pagination", default=1) + page_size: Optional[int] = Field(description="Number of items per page", default=50) + + class Config: + json_schema_extra = { + "examples": [{ + "version": "v2", + "filters": { + "AND": [ + {"user_id": "alex"}, + {"created_at": {"gte": "2024-07-01", "lte": "2024-07-31"}}, + {"categories": {"contains": "food_preferences"}} + ] + }, + "page": 1, + "page_size": 50 + }] + } +``` + +#### Implementation + +```python +def get_all_memory(version: str, filters: Dict[str, Any], page: int = 1, page_size: int = 50) -> Any: + """Retrieve all memories matching the specified criteria.""" + return client.get_all(version=version, filters=filters, page=page, page_size=page_size) + +get_all_tool = StructuredTool( + name="get_all_memory", + description="Retrieve all memories matching specified filters", + func=get_all_memory, + args_schema=GetAllMemoryInput +) +``` + +#### Example Usage + + +```python Code +get_all_input = { + "version": "v2", + "filters": { + "AND": [ + {"user_id": "alex"}, + {"created_at": {"gte": "2024-07-01", "lte": "2024-12-31"}} + ] + }, + "page": 1, + "page_size": 50 +} +get_all_result = get_all_tool.invoke(get_all_input) +``` + +```json Output +{ + "count": 3, + "next": null, + "previous": null, + "results": [ + { + "id": "1a75e827-7eca-45ea-8c5c-cfd43299f061", + "memory": "Name is Alex", + "user_id": "alex", + "hash": "d0fccc8fa47f7a149ee95750c37bb0ca", + "metadata": { + "food": "vegan" + }, + "categories": [ + "personal_details" + ], + "created_at": "2024-11-27T16:53:43.276872-08:00", + "updated_at": "2024-11-27T16:53:43.276885-08:00" + }, + { + "id": "91509588-0b39-408a-8df3-84b3bce8c521", + "memory": "Is a vegetarian", + "user_id": "alex", + "hash": "ce6b1c84586772ab9995a9477032df99", + "metadata": { + "food": "vegan" + }, + "categories": [ + "user_preferences", + "food" + ], + "created_at": "2024-11-27T16:53:43.308027-08:00", + "updated_at": "2024-11-27T16:53:43.308037-08:00" + }, + { + "id": "8d74f7a0-6107-4589-bd6f-210f6bf4fbbb", + "memory": "Is allergic to nuts", + "user_id": "alex", + "hash": "7873cd0e5a29c513253d9fad038e758b", + "metadata": { + "food": "vegan" + }, + "categories": [ + "health" + ], + "created_at": "2024-11-27T16:53:43.337253-08:00", + "updated_at": "2024-11-27T16:53:43.337262-08:00" + } + ] +} +``` + + +## Integration with AI Agents + +All tools are implemented as Langchain `StructuredTool` instances, making them compatible with any AI agent that supports the Langchain tools interface. To use these tools with your agent: + +1. Initialize the tools as shown above +2. Add the tools to your agent's toolset +3. The agent can now use these tools to manage memories through natural language interactions + +Each tool provides structured input validation through Pydantic models and returns consistent responses that can be processed by your agent. + +## Help + +In case of any questions, please feel free to reach out to us using one of the following methods: + + diff --git a/docs/v0x/integrations/langchain.mdx b/docs/v0x/integrations/langchain.mdx new file mode 100644 index 000000000..f79499e7a --- /dev/null +++ b/docs/v0x/integrations/langchain.mdx @@ -0,0 +1,171 @@ +--- +title: Langchain +--- + +Build a personalized Travel Agent AI using LangChain for conversation flow and Mem0 for memory retention. This integration enables context-aware and efficient travel planning experiences. + +## Overview + +In this guide, we'll create a Travel Agent AI that: +1. Uses LangChain to manage conversation flow +2. Leverages Mem0 to store and retrieve relevant information from past interactions +3. Provides personalized travel recommendations based on user history + +## Setup and Configuration + +Install necessary libraries: + +```bash +pip install langchain langchain_openai mem0ai python-dotenv +``` + +Import required modules and set up configurations: + +Remember to get the Mem0 API key from [Mem0 Platform](https://app.mem0.ai). + +```python +import os +from typing import List, Dict +from langchain_openai import ChatOpenAI +from langchain_core.messages import SystemMessage, HumanMessage, AIMessage +from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder +from mem0 import MemoryClient +from dotenv import load_dotenv + +load_dotenv() + +# Configuration +# os.environ["OPENAI_API_KEY"] = "your-openai-api-key" +# os.environ["MEM0_API_KEY"] = "your-mem0-api-key" + +# Initialize LangChain and Mem0 +llm = ChatOpenAI(model="gpt-4o-mini") +mem0 = MemoryClient() +``` + +## Create Prompt Template + +Set up the conversation prompt template: + +```python +prompt = ChatPromptTemplate.from_messages([ + SystemMessage(content="""You are a helpful travel agent AI. Use the provided context to personalize your responses and remember user preferences and past interactions. + Provide travel recommendations, itinerary suggestions, and answer questions about destinations. + If you don't have specific information, you can make general suggestions based on common travel knowledge."""), + MessagesPlaceholder(variable_name="context"), + HumanMessage(content="{input}") +]) +``` + +## Define Helper Functions + +Create functions to handle context retrieval, response generation, and addition to Mem0: + +```python +def retrieve_context(query: str, user_id: str) -> List[Dict]: + """Retrieve relevant context from Mem0""" + try: + memories = mem0.search(query, user_id=user_id, output_format='v1.1') + memory_list = memories['results'] + + serialized_memories = ' '.join([mem["memory"] for mem in memory_list]) + context = [ + { + "role": "system", + "content": f"Relevant information: {serialized_memories}" + }, + { + "role": "user", + "content": query + } + ] + return context + except Exception as e: + print(f"Error retrieving memories: {e}") + # Return empty context if there's an error + return [{"role": "user", "content": query}] + +def generate_response(input: str, context: List[Dict]) -> str: + """Generate a response using the language model""" + chain = prompt | llm + response = chain.invoke({ + "context": context, + "input": input + }) + return response.content + +def save_interaction(user_id: str, user_input: str, assistant_response: str): + """Save the interaction to Mem0""" + try: + interaction = [ + { + "role": "user", + "content": user_input + }, + { + "role": "assistant", + "content": assistant_response + } + ] + result = mem0.add(interaction, user_id=user_id, output_format='v1.1') + print(f"Memory saved successfully: {len(result.get('results', []))} memories added") + except Exception as e: + print(f"Error saving interaction: {e}") +``` + +## Create Chat Turn Function + +Implement the main function to manage a single turn of conversation: + +```python +def chat_turn(user_input: str, user_id: str) -> str: + # Retrieve context + context = retrieve_context(user_input, user_id) + + # Generate response + response = generate_response(user_input, context) + + # Save interaction + save_interaction(user_id, user_input, response) + + return response +``` + +## Main Interaction Loop + +Set up the main program loop for user interaction: + +```python +if __name__ == "__main__": + print("Welcome to your personal Travel Agent Planner! How can I assist you with your travel plans today?") + user_id = "alice" + + while True: + user_input = input("You: ") + if user_input.lower() in ['quit', 'exit', 'bye']: + print("Travel Agent: Thank you for using our travel planning service. Have a great trip!") + break + + response = chat_turn(user_input, user_id) + print(f"Travel Agent: {response}") +``` + +## Key Features + +1. **Memory Integration**: Uses Mem0 to store and retrieve relevant information from past interactions. +2. **Personalization**: Provides context-aware responses based on user history and preferences. +3. **Flexible Architecture**: LangChain structure allows for easy expansion of the conversation flow. +4. **Continuous Learning**: Each interaction is stored, improving future responses. + +## Conclusion + +By integrating LangChain with Mem0, you can build a personalized Travel Agent AI that can maintain context across interactions and provide tailored travel recommendations and assistance. + +## Help + +- For more details on LangChain, visit the [LangChain documentation](https://python.langchain.com/). +- [Mem0 Platform](https://app.mem0.ai/). +- If you need further assistance, please feel free to reach out to us through the following methods: + + + diff --git a/docs/v0x/integrations/langgraph.mdx b/docs/v0x/integrations/langgraph.mdx new file mode 100644 index 000000000..0755dacee --- /dev/null +++ b/docs/v0x/integrations/langgraph.mdx @@ -0,0 +1,172 @@ +--- +title: LangGraph +--- + +Build a personalized Customer Support AI Agent using LangGraph for conversation flow and Mem0 for memory retention. This integration enables context-aware and efficient support experiences. + +## Overview + +In this guide, we'll create a Customer Support AI Agent that: +1. Uses LangGraph to manage conversation flow +2. Leverages Mem0 to store and retrieve relevant information from past interactions +3. Provides personalized responses based on user history + +## Setup and Configuration + +Install necessary libraries: + +```bash +pip install langgraph langchain-openai mem0ai python-dotenv +``` + + +Import required modules and set up configurations: + +Remember to get the Mem0 API key from [Mem0 Platform](https://app.mem0.ai). + +```python +from typing import Annotated, TypedDict, List +from langgraph.graph import StateGraph, START +from langgraph.graph.message import add_messages +from langchain_openai import ChatOpenAI +from mem0 import MemoryClient +from langchain_core.messages import SystemMessage, HumanMessage, AIMessage +from dotenv import load_dotenv + +load_dotenv() + +# Configuration +# OPENAI_API_KEY = 'sk-xxx' # Replace with your actual OpenAI API key +# MEM0_API_KEY = 'your-mem0-key' # Replace with your actual Mem0 API key + +# Initialize LangChain and Mem0 +llm = ChatOpenAI(model="gpt-4") +mem0 = MemoryClient() +``` + +## Define State and Graph + +Set up the conversation state and LangGraph structure: + +```python +class State(TypedDict): + messages: Annotated[List[HumanMessage | AIMessage], add_messages] + mem0_user_id: str + +graph = StateGraph(State) +``` + +## Create Chatbot Function + +Define the core logic for the Customer Support AI Agent: + +```python +def chatbot(state: State): + messages = state["messages"] + user_id = state["mem0_user_id"] + + try: + # Retrieve relevant memories + memories = mem0.search(messages[-1].content, user_id=user_id, output_format='v1.1') + + # Handle dict response format + memory_list = memories['results'] + + context = "Relevant information from previous conversations:\n" + for memory in memory_list: + context += f"- {memory['memory']}\n" + + system_message = SystemMessage(content=f"""You are a helpful customer support assistant. Use the provided context to personalize your responses and remember user preferences and past interactions. +{context}""") + + full_messages = [system_message] + messages + response = llm.invoke(full_messages) + + # Store the interaction in Mem0 + try: + interaction = [ + { + "role": "user", + "content": messages[-1].content + }, + { + "role": "assistant", + "content": response.content + } + ] + result = mem0.add(interaction, user_id=user_id, output_format='v1.1') + print(f"Memory saved: {len(result.get('results', []))} memories added") + except Exception as e: + print(f"Error saving memory: {e}") + + return {"messages": [response]} + + except Exception as e: + print(f"Error in chatbot: {e}") + # Fallback response without memory context + response = llm.invoke(messages) + return {"messages": [response]} +``` + +## Set Up Graph Structure + +Configure the LangGraph with appropriate nodes and edges: + +```python +graph.add_node("chatbot", chatbot) +graph.add_edge(START, "chatbot") +graph.add_edge("chatbot", "chatbot") + +compiled_graph = graph.compile() +``` + +## Create Conversation Runner + +Implement a function to manage the conversation flow: + +```python +def run_conversation(user_input: str, mem0_user_id: str): + config = {"configurable": {"thread_id": mem0_user_id}} + state = {"messages": [HumanMessage(content=user_input)], "mem0_user_id": mem0_user_id} + + for event in compiled_graph.stream(state, config): + for value in event.values(): + if value.get("messages"): + print("Customer Support:", value["messages"][-1].content) + return +``` + +## Main Interaction Loop + +Set up the main program loop for user interaction: + +```python +if __name__ == "__main__": + print("Welcome to Customer Support! How can I assist you today?") + mem0_user_id = "alice" # You can generate or retrieve this based on your user management system + while True: + user_input = input("You: ") + if user_input.lower() in ['quit', 'exit', 'bye']: + print("Customer Support: Thank you for contacting us. Have a great day!") + break + run_conversation(user_input, mem0_user_id) +``` + +## Key Features + +1. **Memory Integration**: Uses Mem0 to store and retrieve relevant information from past interactions. +2. **Personalization**: Provides context-aware responses based on user history. +3. **Flexible Architecture**: LangGraph structure allows for easy expansion of the conversation flow. +4. **Continuous Learning**: Each interaction is stored, improving future responses. + +## Conclusion + +By integrating LangGraph with Mem0, you can build a personalized Customer Support AI Agent that can maintain context across interactions and provide personalized assistance. + +## Help + +- For more details on LangGraph, visit the [LangChain documentation](https://python.langchain.com/docs/langgraph). +- [Mem0 Platform](https://app.mem0.ai/). +- If you need further assistance, please feel free to reach out to us through following methods: + + diff --git a/docs/v0x/integrations/livekit.mdx b/docs/v0x/integrations/livekit.mdx new file mode 100644 index 000000000..ad44235e5 --- /dev/null +++ b/docs/v0x/integrations/livekit.mdx @@ -0,0 +1,238 @@ +--- +title: Livekit +--- + +This guide demonstrates how to create a memory-enabled voice assistant using LiveKit, Deepgram, OpenAI, and Mem0, focusing on creating an intelligent, context-aware travel planning agent. + +## Prerequisites + +Before you begin, make sure you have: + +1. Installed Livekit Agents SDK with voice dependencies of silero and deepgram: +```bash +pip install livekit livekit-agents \ +livekit-plugins-silero \ +livekit-plugins-deepgram \ +livekit-plugins-openai \ +livekit-plugins-turn-detector \ +livekit-plugins-noise-cancellation +``` + +2. Installed Mem0 SDK: +```bash +pip install mem0ai +``` + +3. Set up your API keys in a `.env` file: +```sh +LIVEKIT_URL=your_livekit_url +LIVEKIT_API_KEY=your_livekit_api_key +LIVEKIT_API_SECRET=your_livekit_api_secret +DEEPGRAM_API_KEY=your_deepgram_api_key +MEM0_API_KEY=your_mem0_api_key +OPENAI_API_KEY=your_openai_api_key +``` + +> **Note**: Make sure to have a Livekit and Deepgram account. You can find these variables `LIVEKIT_URL` , `LIVEKIT_API_KEY` and `LIVEKIT_API_SECRET` from [LiveKit Cloud Console](https://cloud.livekit.io/) and for more information you can refer this website [LiveKit Documentation](https://docs.livekit.io/home/cloud/keys-and-tokens/). For `DEEPGRAM_API_KEY` you can get from [Deepgram Console](https://console.deepgram.com/) refer this website [Deepgram Documentation](https://developers.deepgram.com/docs/create-additional-api-keys) for more details. + +## Code Breakdown + +Let's break down the key components of this implementation using LiveKit Agents: + +### 1. Setting Up Dependencies and Environment + +```python +import os +import logging +from pathlib import Path +from dotenv import load_dotenv + +from mem0 import AsyncMemoryClient + +from livekit.agents import ( + JobContext, + WorkerOptions, + cli, + ChatContext, + ChatMessage, + RoomInputOptions, + Agent, + AgentSession, +) +from livekit.plugins import openai, silero, deepgram, noise_cancellation +from livekit.plugins.turn_detector.english import EnglishModel + +# Load environment variables +load_dotenv() + +``` + +### 2. Mem0 Client and Agent Definition + +```python +# User ID for RAG data in Mem0 +RAG_USER_ID = "livekit-mem0" +mem0_client = AsyncMemoryClient() + +class MemoryEnabledAgent(Agent): + """ + An agent that can answer questions using RAG (Retrieval Augmented Generation) with Mem0. + """ + def __init__(self) -> None: + super().__init__( + instructions=""" + You are a helpful voice assistant. + You are a travel guide named George and will help the user to plan a travel trip of their dreams. + You should help the user plan for various adventures like work retreats, family vacations or solo backpacking trips. + You should be careful to not suggest anything that would be dangerous, illegal or inappropriate. + You can remember past interactions and use them to inform your answers. + Use semantic memory retrieval to provide contextually relevant responses. + """, + ) + self._seen_results = set() # Track previously seen result IDs + logger.info(f"Mem0 Agent initialized. Using user_id: {RAG_USER_ID}") + + async def on_enter(self): + self.session.generate_reply( + instructions="Briefly greet the user and offer your assistance." + ) + + async def on_user_turn_completed(self, turn_ctx: ChatContext, new_message: ChatMessage) -> None: + # Persist the user message in Mem0 + try: + logger.info(f"Adding user message to Mem0: {new_message.text_content}") + add_result = await mem0_client.add( + [{"role": "user", "content": new_message.text_content}], + user_id=RAG_USER_ID + ) + logger.info(f"Mem0 add result (user): {add_result}") + except Exception as e: + logger.warning(f"Failed to store user message in Mem0: {e}") + + # RAG: Retrieve relevant context from Mem0 and inject as assistant message + try: + logger.info("About to await mem0_client.search for RAG context") + search_results = await mem0_client.search( + new_message.text_content, + user_id=RAG_USER_ID, + ) + logger.info(f"mem0_client.search returned: {search_results}") + if search_results and search_results.get('results', []): + context_parts = [] + for result in search_results.get('results', []): + paragraph = result.get("memory") or result.get("text") + if paragraph: + source = "mem0 Memories" + if "from [" in paragraph: + source = paragraph.split("from [")[1].split("]")[0] + paragraph = paragraph.split("]")[1].strip() + context_parts.append(f"Source: {source}\nContent: {paragraph}\n") + if context_parts: + full_context = "\n\n".join(context_parts) + logger.info(f"Injecting RAG context: {full_context}") + turn_ctx.add_message(role="assistant", content=full_context) + await self.update_chat_ctx(turn_ctx) + except Exception as e: + logger.warning(f"Failed to inject RAG context from Mem0: {e}") + + await super().on_user_turn_completed(turn_ctx, new_message) +``` + +### 3. Entrypoint and Session Setup + +```python +async def entrypoint(ctx: JobContext): + """Main entrypoint for the agent.""" + await ctx.connect() + + session = AgentSession( + stt=deepgram.STT(), + llm=openai.LLM(model="gpt-4o-mini"), + tts=openai.TTS(voice="ash",), + turn_detection=EnglishModel(), + vad=silero.VAD.load(), + ) + + await session.start( + agent=MemoryEnabledAgent(), + room=ctx.room, + room_input_options=RoomInputOptions( + noise_cancellation=noise_cancellation.BVC(), + ), + ) + + # Initial greeting + await session.generate_reply( + instructions="Greet the user warmly as George the travel guide and ask how you can help them plan their next adventure.", + allow_interruptions=True + ) + +# Run the application +if __name__ == "__main__": + cli.run_app(WorkerOptions(entrypoint_fnc=entrypoint)) +``` + +## Key Features of This Implementation + +1. **Semantic Memory Retrieval**: Uses Mem0 to store and retrieve contextually relevant memories +2. **Voice Interaction**: Leverages LiveKit for voice communication with proper turn detection +3. **Intelligent Context Management**: Augments conversations with past interactions +4. **Travel Planning Specialization**: Focused on creating a helpful travel guide assistant +5. **Function Tools**: Modern tool definition for enhanced capabilities + +## Running the Example + +To run this example: + +1. Install all required dependencies +2. Set up your `.env` file with the necessary API keys +3. Ensure your microphone and audio setup are configured +4. Run the script with Python 3.11 or newer and with the following command: +```sh +python mem0-livekit-voice-agent.py start +``` +or to start your agent in console mode to run inside your terminal: + +```sh +python mem0-livekit-voice-agent.py console +``` +5. After the script starts, you can interact with the voice agent using [Livekit's Agent Platform](https://agents-playground.livekit.io/) and connect to the agent inorder to start conversations. + +## Best Practices for Voice Agents with Memory + +1. **Context Preservation**: Store enough context with each memory for effective retrieval +2. **Privacy Considerations**: Implement secure memory management +3. **Relevant Memory Filtering**: Use semantic search to retrieve only the most relevant memories +4. **Error Handling**: Implement robust error handling for memory operations + +## Debugging Function Tools + +- To run the script in debug mode simply start the assistant with `dev` mode: +```sh +python mem0-livekit-voice-agent.py dev +``` + +- When working with memory-enabled voice agents, use Python's `logging` module for effective debugging: + +```python +import logging + +# Set up logging +logging.basicConfig( + level=logging.DEBUG, + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' +) +logger = logging.getLogger("memory_voice_agent") +``` + +- Check the logs for any issues with API keys, connectivity, or memory operations. +- Ensure your `.env` file is correctly configured and loaded. + + +## Help & Resources + +- [LiveKit Documentation](https://docs.livekit.io/) +- [Mem0 Platform](https://app.mem0.ai/) +- Need assistance? Reach out through: + + diff --git a/docs/v0x/integrations/llama-index.mdx b/docs/v0x/integrations/llama-index.mdx new file mode 100644 index 000000000..8316a449d --- /dev/null +++ b/docs/v0x/integrations/llama-index.mdx @@ -0,0 +1,218 @@ +--- +title: LlamaIndex +--- + +LlamaIndex supports Mem0 as a [memory store](https://llamahub.ai/l/memory/llama-index-memory-mem0). In this guide, we'll show you how to use it. + + + 🎉 Exciting news! [**Mem0Memory**](https://docs.llamaindex.ai/en/stable/examples/memory/Mem0Memory/) now supports **ReAct** and **FunctionCalling** agents. + + +### Installation + +To install the required package, run: + +```bash +pip install llama-index-core llama-index-memory-mem0 python-dotenv +``` + +### Setup with Mem0 Platform + +Set your Mem0 Platform API key as an environment variable. You can replace `` with your actual API key: + + + You can obtain your Mem0 Platform API key from the [Mem0 Platform](https://app.mem0.ai/login). + + +```python +from dotenv import load_dotenv +import os + +load_dotenv() + +# os.environ["MEM0_API_KEY"] = "" +``` + +Import the necessary modules and create a Mem0Memory instance: +```python +from llama_index.memory.mem0 import Mem0Memory + +context = {"user_id": "alice"} +memory_from_client = Mem0Memory.from_client( + context=context, + search_msg_limit=4, # optional, default is 5 + output_format='v1.1', # Remove deprecation warnings +) +``` + +Context is used to identify the user, agent or the conversation in the Mem0. It is required to be passed in the at least one of the fields in the `Mem0Memory` constructor. It can be any of the following: + +```python +context = { + "user_id": "alice", + "agent_id": "llama_agent_1", + "run_id": "run_1", +} +``` + +`search_msg_limit` is optional, default is 5. It is the number of messages from the chat history to be used for memory retrieval from Mem0. More number of messages will result in more context being used for retrieval but will also increase the retrieval time and might result in some unwanted results. + + + `search_msg_limit` is different from `limit`. `limit` is the number of messages to be retrieved from Mem0 and is used in search. + + +### Setup with Mem0 OSS + +Set your Mem0 OSS by providing configuration details: + + + To know more about Mem0 OSS, read [Mem0 OSS Quickstart](https://docs.mem0.ai/open-source/overview). + + +```python +config = { + "vector_store": { + "provider": "qdrant", + "config": { + "collection_name": "test_9", + "host": "localhost", + "port": 6333, + "embedding_model_dims": 1536, # Change this according to your local model's dimensions + }, + }, + "llm": { + "provider": "openai", + "config": { + "model": "gpt-4o", + "temperature": 0.2, + "max_tokens": 2000, + }, + }, + "embedder": { + "provider": "openai", + "config": {"model": "text-embedding-3-small"}, + }, + "version": "v1.1", +} +``` + +Create a Mem0Memory instance: + +```python +memory_from_config = Mem0Memory.from_config( + context=context, + config=config, + search_msg_limit=4, # optional, default is 5 + output_format='v1.1', # Remove deprecation warnings +) +``` + +Initialize the LLM + +```python +from llama_index.llms.openai import OpenAI +from dotenv import load_dotenv + +load_dotenv() + +# os.environ["OPENAI_API_KEY"] = "" +llm = OpenAI(model="gpt-4o-mini") +``` + +### SimpleChatEngine +Use the `SimpleChatEngine` to start a chat with the agent with the memory. + +```python +from llama_index.core.chat_engine import SimpleChatEngine + +agent = SimpleChatEngine.from_defaults( + llm=llm, memory=memory_from_client # or memory_from_config +) + +# Start the chat +response = agent.chat("Hi, My name is Alice") +print(response) +``` +Now we will learn how to use Mem0 with FunctionCalling and ReAct agents. + +Initialize the tools: + +```python +from llama_index.core.tools import FunctionTool + + +def call_fn(name: str): + """Call the provided name. + Args: + name: str (Name of the person) + """ + print(f"Calling... {name}") + + +def email_fn(name: str): + """Email the provided name. + Args: + name: str (Name of the person) + """ + print(f"Emailing... {name}") + + +call_tool = FunctionTool.from_defaults(fn=call_fn) +email_tool = FunctionTool.from_defaults(fn=email_fn) +``` +### FunctionCallingAgent + +```python +from llama_index.core.agent import FunctionCallingAgent + +agent = FunctionCallingAgent.from_tools( + [call_tool, email_tool], + llm=llm, + memory=memory_from_client, # or memory_from_config + verbose=True, +) + +# Start the chat +response = agent.chat("Hi, My name is Alice") +print(response) +``` + +### ReActAgent + +```python +from llama_index.core.agent import ReActAgent + +agent = ReActAgent.from_tools( + [call_tool, email_tool], + llm=llm, + memory=memory_from_client, # or memory_from_config + verbose=True, +) + +# Start the chat +response = agent.chat("Hi, My name is Alice") +print(response) +``` + +## Key Features + +1. **Memory Integration**: Uses Mem0 to store and retrieve relevant information from past interactions. +2. **Personalization**: Provides context-aware agent responses based on user history and preferences. +3. **Flexible Architecture**: LlamaIndex allows for easy integration of the memory with the agent. +4. **Continuous Learning**: Each interaction is stored, improving future responses. + +## Conclusion + +By integrating LlamaIndex with Mem0, you can build a personalized agent that can maintain context across interactions with the agent and provide tailored recommendations and assistance. + +## Help + +- For more details on LlamaIndex, visit the [LlamaIndex documentation](https://llamahub.ai/l/memory/llama-index-memory-mem0). +- [Mem0 Platform](https://app.mem0.ai/). +- If you need further assistance, please feel free to reach out to us through following methods: + + + + + + diff --git a/docs/v0x/integrations/mastra.mdx b/docs/v0x/integrations/mastra.mdx new file mode 100644 index 000000000..9b126a44a --- /dev/null +++ b/docs/v0x/integrations/mastra.mdx @@ -0,0 +1,134 @@ +--- +title: Mastra +--- + +The [**Mastra**](https://mastra.ai/) integration demonstrates how to use Mastra's agent system with Mem0 as the memory backend through custom tools. This enables agents to remember and recall information across conversations. + +## Overview + +In this guide, we'll create a Mastra agent that: +1. Uses Mem0 to store information using a memory tool +2. Retrieves relevant memories using a search tool +3. Provides personalized responses based on past interactions +4. Maintains context across conversations and sessions + +## Setup and Configuration + +Install the required libraries: + +```bash +npm install @mastra/core @mastra/mem0 @ai-sdk/openai zod +``` + +Set up your environment variables: + +Remember to get the Mem0 API key from [Mem0 Platform](https://app.mem0.ai). + +```bash +MEM0_API_KEY=your-mem0-api-key +OPENAI_API_KEY=your-openai-api-key +``` + +## Initialize Mem0 Integration + +Import required modules and set up the Mem0 integration: + +```typescript +import { Mem0Integration } from '@mastra/mem0'; +import { createTool } from '@mastra/core/tools'; +import { Agent } from '@mastra/core/agent'; +import { openai } from '@ai-sdk/openai'; +import { z } from 'zod'; + +// Initialize Mem0 integration +const mem0 = new Mem0Integration({ + config: { + apiKey: process.env.MEM0_API_KEY || '', + user_id: 'alice', // Unique user identifier + }, +}); +``` + +## Create Memory Tools + +Set up tools for memorizing and remembering information: + +```typescript +// Tool for remembering saved memories +const mem0RememberTool = createTool({ + id: 'Mem0-remember', + description: "Remember your agent memories that you've previously saved using the Mem0-memorize tool.", + inputSchema: z.object({ + question: z.string().describe('Question used to look up the answer in saved memories.'), + }), + outputSchema: z.object({ + answer: z.string().describe('Remembered answer'), + }), + execute: async ({ context }) => { + console.log(`Searching memory "${context.question}"`); + const memory = await mem0.searchMemory(context.question); + console.log(`\nFound memory "${memory}"\n`); + + return { + answer: memory, + }; + }, +}); + +// Tool for saving new memories +const mem0MemorizeTool = createTool({ + id: 'Mem0-memorize', + description: 'Save information to mem0 so you can remember it later using the Mem0-remember tool.', + inputSchema: z.object({ + statement: z.string().describe('A statement to save into memory'), + }), + execute: async ({ context }) => { + console.log(`\nCreating memory "${context.statement}"\n`); + // To reduce latency, memories can be saved async without blocking tool execution + void mem0.createMemory(context.statement).then(() => { + console.log(`\nMemory "${context.statement}" saved.\n`); + }); + return { success: true }; + }, +}); +``` + +## Create Mastra Agent + +Initialize an agent with memory tools and clear instructions: + +```typescript +// Create an agent with memory tools +const mem0Agent = new Agent({ + name: 'Mem0 Agent', + instructions: ` + You are a helpful assistant that has the ability to memorize and remember facts using Mem0. + Use the Mem0-memorize tool to save important information that might be useful later. + Use the Mem0-remember tool to recall previously saved information when answering questions. + `, + model: openai('gpt-4o'), + tools: { mem0RememberTool, mem0MemorizeTool }, +}); +``` + + +## Key Features + +1. **Tool-based Memory Control**: The agent decides when to save and retrieve information using specific tools +2. **Semantic Search**: Mem0 finds relevant memories based on semantic similarity, not just exact matches +3. **User-specific Memory Spaces**: Each user_id maintains separate memory contexts +4. **Asynchronous Saving**: Memories are saved in the background to reduce response latency +5. **Cross-conversation Persistence**: Memories persist across different conversation threads +6. **Transparent Operations**: Memory operations are visible through tool usage + +## Conclusion + +By integrating Mastra with Mem0, you can build intelligent agents that learn and remember information across conversations. The tool-based approach provides transparency and control over memory operations, making it easy to create personalized and context-aware AI experiences. + +## Help + +- For more details on Mastra, visit the [Mastra documentation](https://docs.mastra.ai/). +- [Mem0 Platform](https://app.mem0.ai/). +- If you need further assistance, please feel free to reach out to us through the following methods: + + \ No newline at end of file diff --git a/docs/v0x/integrations/openai-agents-sdk.mdx b/docs/v0x/integrations/openai-agents-sdk.mdx new file mode 100644 index 000000000..084a89607 --- /dev/null +++ b/docs/v0x/integrations/openai-agents-sdk.mdx @@ -0,0 +1,234 @@ +--- +title: OpenAI Agents SDK +--- + +Integrate [**Mem0**](https://github.com/mem0ai/mem0) with [OpenAI Agents SDK](https://github.com/openai/openai-agents-python), a lightweight framework for building multi-agent workflows. This integration enables agents to access persistent memory across conversations, enhancing context retention and personalization. + +## Overview + +1. Store and retrieve memories from Mem0 within OpenAI agents +2. Multi-agent workflows with shared memory +3. Retrieve relevant memories for past conversations +4. Personalized responses based on user history + +## Prerequisites + +Before setting up Mem0 with OpenAI Agents SDK, ensure you have: + +1. Installed the required packages: +```bash +pip install openai-agents mem0ai +``` + +2. Valid API keys: + - [Mem0 API Key](https://app.mem0.ai/dashboard/api-keys) + - [OpenAI API Key](https://platform.openai.com/api-keys) + +## Basic Integration Example + +The following example demonstrates how to create an OpenAI agent with Mem0 memory integration: + +```python +import os +from agents import Agent, Runner, function_tool +from mem0 import MemoryClient + +# Set up environment variables +os.environ["OPENAI_API_KEY"] = "your-openai-api-key" +os.environ["MEM0_API_KEY"] = "your-mem0-api-key" + +# Initialize Mem0 client +mem0 = MemoryClient() + +# Define memory tools for the agent +@function_tool +def search_memory(query: str, user_id: str) -> str: + """Search through past conversations and memories""" + memories = mem0.search(query, user_id=user_id, limit=3) + if memories and memories.get('results'): + return "\n".join([f"- {mem['memory']}" for mem in memories['results']]) + return "No relevant memories found." + +@function_tool +def save_memory(content: str, user_id: str) -> str: + """Save important information to memory""" + mem0.add([{"role": "user", "content": content}], user_id=user_id) + return "Information saved to memory." + +# Create agent with memory capabilities +agent = Agent( + name="Personal Assistant", + instructions="""You are a helpful personal assistant with memory capabilities. + Use the search_memory tool to recall past conversations and user preferences. + Use the save_memory tool to store important information about the user. + Always personalize your responses based on available memory.""", + tools=[search_memory, save_memory], + model="gpt-4o" +) + +def chat_with_agent(user_input: str, user_id: str) -> str: + """ + Handle user input with automatic memory integration. + + Args: + user_input: The user's message + user_id: Unique identifier for the user + + Returns: + The agent's response + """ + # Run the agent (it will automatically use memory tools when needed) + result = Runner.run_sync(agent, user_input) + + return result.final_output + +# Example usage +if __name__ == "__main__": + + # preferences will be saved in memory (using save_memory tool) + response_1 = chat_with_agent( + "I love Italian food and I'm planning a trip to Rome next month", + user_id="alice" + ) + print(response_1) + + # memory will be retrieved using search_memory tool to answer the user query + response_2 = chat_with_agent( + "Give me some recommendations for food", + user_id="alice" + ) + print(response_2) +``` + +## Multi-Agent Workflow with Handoffs + +Create multiple specialized agents with proper handoffs and shared memory: + +```python +from agents import Agent, Runner, handoffs, function_tool + +# Specialized agents +travel_agent = Agent( + name="Travel Planner", + instructions="""You are a travel planning specialist. Use get_user_context to + understand the user's travel preferences and history before making recommendations. + After providing your response, use store_conversation to save important details.""", + tools=[search_memory, save_memory], + model="gpt-4o" +) + +health_agent = Agent( + name="Health Advisor", + instructions="""You are a health and wellness advisor. Use get_user_context to + understand the user's health goals and dietary preferences. + After providing advice, use store_conversation to save relevant information.""", + tools=[search_memory, save_memory], + model="gpt-4o" +) + +# Triage agent with handoffs +triage_agent = Agent( + name="Personal Assistant", + instructions="""You are a helpful personal assistant that routes requests to specialists. + For travel-related questions (trips, hotels, flights, destinations), hand off to Travel Planner. + For health-related questions (fitness, diet, wellness, exercise), hand off to Health Advisor. + For general questions, you can handle them directly using available tools.""", + handoffs=[travel_agent, health_agent], + model="gpt-4o" +) + +def chat_with_handoffs(user_input: str, user_id: str) -> str: + """ + Handle user input with automatic agent handoffs and memory integration. + + Args: + user_input: The user's message + user_id: Unique identifier for the user + + Returns: + The agent's response + """ + # Run the triage agent (it will automatically handoff when needed) + result = Runner.run_sync(triage_agent, user_input) + + # Store the original conversation in memory + conversation = [ + {"role": "user", "content": user_input}, + {"role": "assistant", "content": result.final_output} + ] + mem0.add(conversation, user_id=user_id) + + return result.final_output + +# Example usage +response = chat_with_handoffs("Plan a healthy meal for my Italy trip", user_id="alex") +print(response) +``` + +## Quick Start Chat Interface + +Simple interactive chat with memory: + +```python +def interactive_chat(): + """Interactive chat interface with memory and handoffs""" + user_id = input("Enter your user ID: ") or "demo_user" + print(f"Chat started for user: {user_id}") + print("Type 'quit' to exit\n") + + while True: + user_input = input("You: ") + if user_input.lower() == 'quit': + break + + response = chat_with_handoffs(user_input, user_id) + print(f"Assistant: {response}\n") + +if __name__ == "__main__": + interactive_chat() +``` + +## Key Features + +### 1. Automatic Memory Integration +- **Tool-Based Memory**: Agents use function tools to search and save memories +- **Conversation Storage**: All interactions are automatically stored +- **Context Retrieval**: Agents can access relevant past conversations + +### 2. Multi-Agent Memory Sharing +- **Shared Context**: Multiple agents access the same memory store +- **Specialized Agents**: Create domain-specific agents with shared memory +- **Seamless Handoffs**: Agents maintain context across handoffs + +### 3. Flexible Memory Operations +- **Retrieve Capabilities**: Retrieve relevant memories from previous conversation +- **User Segmentation**: Organize memories by user ID +- **Memory Management**: Built-in tools for saving and retrieving information + +## Configuration Options + +Customize memory behavior: + +```python +# Configure memory search +memories = mem0.search( + query="travel preferences", + user_id="alex", + limit=5 # Number of memories to retrieve +) + +# Add metadata to memories +mem0.add( + messages=[{"role": "user", "content": "I prefer luxury hotels"}], + user_id="alex", + metadata={"category": "travel", "importance": "high"} +) +``` + +## Help + +- [OpenAI Agents SDK Documentation](https://openai.github.io/openai-agents-python/) +- [Mem0 Platform](https://app.mem0.ai/) +- If you need further assistance, please feel free to reach out to us through the following methods: + + \ No newline at end of file diff --git a/docs/v0x/integrations/pipecat.mdx b/docs/v0x/integrations/pipecat.mdx new file mode 100644 index 000000000..626edb29b --- /dev/null +++ b/docs/v0x/integrations/pipecat.mdx @@ -0,0 +1,218 @@ +--- +title: 'Pipecat' +description: 'Integrate Mem0 with Pipecat for conversational memory in AI agents' +--- + +# Pipecat Integration + +Mem0 seamlessly integrates with [Pipecat](https://pipecat.ai), providing long-term memory capabilities for conversational AI agents. This integration allows your Pipecat-powered applications to remember past conversations and provide personalized responses based on user history. + +## Installation + +To use Mem0 with Pipecat, install the required dependencies: + +```bash +pip install "pipecat-ai[mem0]" +``` + +You'll also need to set up your Mem0 API key as an environment variable: + +```bash +export MEM0_API_KEY=your_mem0_api_key +``` + +You can obtain a Mem0 API key by signing up at [mem0.ai](https://mem0.ai). + +## Configuration + +Mem0 integration is provided through the `Mem0MemoryService` class in Pipecat. Here's how to configure it: + +```python +from pipecat.services.mem0 import Mem0MemoryService + +memory = Mem0MemoryService( + api_key=os.getenv("MEM0_API_KEY"), # Your Mem0 API key + user_id="unique_user_id", # Unique identifier for the end user + agent_id="my_agent", # Identifier for the agent using the memory + run_id="session_123", # Optional: specific conversation session ID + params={ # Optional: configuration parameters + "search_limit": 10, # Maximum memories to retrieve per query + "search_threshold": 0.1, # Relevance threshold (0.0 to 1.0) + "system_prompt": "Here are your past memories:", # Custom prefix for memories + "add_as_system_message": True, # Add memories as system (True) or user (False) message + "position": 1, # Position in context to insert memories + } +) +``` + +## Pipeline Integration + +The `Mem0MemoryService` should be positioned between your context aggregator and LLM service in the Pipecat pipeline: + +```python +pipeline = Pipeline([ + transport.input(), + stt, # Speech-to-text for audio input + user_context, # User context aggregator + memory, # Mem0 Memory service enhances context here + llm, # LLM for response generation + tts, # Optional: Text-to-speech + transport.output(), + assistant_context # Assistant context aggregator +]) +``` + +## Example: Voice Agent with Memory + +Here's a complete example of a Pipecat voice agent with Mem0 memory integration: + +```python +import asyncio +import os +from fastapi import FastAPI, WebSocket + +from pipecat.frames.frames import TextFrame +from pipecat.pipeline.pipeline import Pipeline +from pipecat.pipeline.task import PipelineTask +from pipecat.pipeline.runner import PipelineRunner +from pipecat.services.mem0 import Mem0MemoryService +from pipecat.services.openai import OpenAILLMService, OpenAIUserContextAggregator, OpenAIAssistantContextAggregator +from pipecat.transports.network.fastapi_websocket import ( + FastAPIWebsocketTransport, + FastAPIWebsocketParams +) +from pipecat.serializers.protobuf import ProtobufFrameSerializer +from pipecat.audio.vad.silero import SileroVADAnalyzer +from pipecat.services.whisper import WhisperSTTService + +app = FastAPI() + +@app.websocket("/chat") +async def websocket_endpoint(websocket: WebSocket): + await websocket.accept() + + # Basic setup with minimal configuration + user_id = "alice" + + # WebSocket transport + transport = FastAPIWebsocketTransport( + websocket=websocket, + params=FastAPIWebsocketParams( + audio_out_enabled=True, + vad_enabled=True, + vad_analyzer=SileroVADAnalyzer(), + vad_audio_passthrough=True, + serializer=ProtobufFrameSerializer(), + ) + ) + + # Core services + user_context = OpenAIUserContextAggregator() + assistant_context = OpenAIAssistantContextAggregator() + stt = WhisperSTTService(api_key=os.getenv("OPENAI_API_KEY")) + + # Memory service - the key component + memory = Mem0MemoryService( + api_key=os.getenv("MEM0_API_KEY"), + user_id=user_id, + agent_id="fastapi_memory_bot" + ) + + # LLM for response generation + llm = OpenAILLMService( + api_key=os.getenv("OPENAI_API_KEY"), + model="gpt-3.5-turbo", + system_prompt="You are a helpful assistant that remembers past conversations." + ) + + # Simple pipeline + pipeline = Pipeline([ + transport.input(), + stt, # Speech-to-text for audio input + user_context, + memory, # Memory service enhances context here + llm, + transport.output(), + assistant_context + ]) + + # Run the pipeline + runner = PipelineRunner() + task = PipelineTask(pipeline) + + # Event handlers for WebSocket connections + @transport.event_handler("on_client_connected") + async def on_client_connected(transport, client): + # Send welcome message when client connects + await task.queue_frame(TextFrame("Hello! I'm a memory bot. I'll remember our conversation.")) + + @transport.event_handler("on_client_disconnected") + async def on_client_disconnected(transport, client): + # Clean up when client disconnects + await task.cancel() + + await runner.run(task) + +if __name__ == "__main__": + import uvicorn + uvicorn.run(app, host="0.0.0.0", port=8000) +``` + +## How It Works + +When integrated with Pipecat, Mem0 provides two key functionalities: + +### 1. Message Storage + +All conversation messages are automatically stored in Mem0 for future reference: +- Captures the full message history from context frames +- Associates messages with the specified user, agent, and run IDs +- Stores metadata to enable efficient retrieval + +### 2. Memory Retrieval + +When a new user message is detected: +1. The message is used as a search query to find relevant past memories +2. Relevant memories are retrieved from Mem0's database +3. Memories are formatted and added to the conversation context +4. The enhanced context is passed to the LLM for response generation + +## Additional Configuration Options + +### Memory Search Parameters + +You can customize how memories are retrieved and used: + +```python +memory = Mem0MemoryService( + api_key=os.getenv("MEM0_API_KEY"), + user_id="user123", + params={ + "search_limit": 5, # Retrieve up to 5 memories + "search_threshold": 0.2, # Higher threshold for more relevant matches + "api_version": "v2", # Mem0 API version + } +) +``` + +### Memory Presentation Options + +Control how memories are presented to the LLM: + +```python +memory = Mem0MemoryService( + api_key=os.getenv("MEM0_API_KEY"), + user_id="user123", + params={ + "system_prompt": "Previous conversations with this user:", + "add_as_system_message": True, # Add as system message instead of user message + "position": 0, # Insert at the beginning of the context + } +) +``` + +## Resources + +- [Mem0 Pipecat Integration](https://docs.pipecat.ai/server/services/memory/mem0) +- [Pipecat Documentation](https://docs.pipecat.ai) + diff --git a/docs/v0x/integrations/raycast.mdx b/docs/v0x/integrations/raycast.mdx new file mode 100644 index 000000000..456bf14df --- /dev/null +++ b/docs/v0x/integrations/raycast.mdx @@ -0,0 +1,45 @@ +--- +title: "Raycast Extension" +description: "Mem0 Raycast extension for intelligent memory management" +--- + +Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. This extension lets you store and retrieve text snippets using Mem0's intelligent memory system. Find Mem0 in [Raycast Store](https://www.raycast.com/dev_khant/mem0) for using it. + +## Getting Started + +**Get your API Key**: You'll need a Mem0 API key to use this extension: + +a. Sign up at [app.mem0.ai](https://app.mem0.ai) + +b. Navigate to your API Keys page + +c. Copy your API key + +d. Enter this key in the extension preferences + +**Basic Usage**: + +- Store memories and text snippets +- Retrieve context-aware information +- Manage persistent user preferences +- Search through stored memories + +## ✨ Features + +**Remember Everything**: Never lose important information - store notes, preferences, and conversations that your AI can recall later + +**Smart Connections**: Automatically links related topics, just like your brain does - helping you discover useful connections + +**Cost Saver**: Spend less on AI usage by efficiently retrieving relevant information instead of regenerating responses + +## 🔑 How This Helps You + +**More Personal Experience**: Your AI remembers your preferences and past conversations, making interactions feel more natural + +**Learn Your Style**: Adapts to how you work and what you like, becoming more helpful over time + +**No More Repetition**: Stop explaining the same things over and over - your AI remembers your context and preferences + +--- + + diff --git a/docs/v0x/integrations/vercel-ai-sdk.mdx b/docs/v0x/integrations/vercel-ai-sdk.mdx new file mode 100644 index 000000000..7983ce0a6 --- /dev/null +++ b/docs/v0x/integrations/vercel-ai-sdk.mdx @@ -0,0 +1,259 @@ +--- +title: Vercel AI SDK +--- + +The [**Mem0 AI SDK Provider**](https://www.npmjs.com/package/@mem0/vercel-ai-provider) is a library developed by **Mem0** to integrate with the Vercel AI SDK. This library brings enhanced AI interaction capabilities to your applications by introducing persistent memory functionality. + + + 🎉 Exciting news! Mem0 AI SDK now supports Vercel AI SDK V5. + + +## Overview + +1. 🧠 Offers persistent memory storage for conversational AI +2. 🔄 Enables smooth integration with the Vercel AI SDK +3. 🚀 Ensures compatibility with multiple LLM providers +4. 📝 Supports structured message formats for clarity +5. ⚡ Facilitates streaming response capabilities + +## Setup and Configuration + +Install the SDK provider using npm: + +```bash +npm install @mem0/vercel-ai-provider +``` + +## Getting Started + +### Setting Up Mem0 + +1. Get your **Mem0 API Key** from the [Mem0 Dashboard](https://app.mem0.ai/dashboard/api-keys). + +2. Initialize the Mem0 Client in your application: + + ```typescript + import { createMem0 } from "@mem0/vercel-ai-provider"; + + const mem0 = createMem0({ + provider: "openai", + mem0ApiKey: "m0-xxx", + apiKey: "provider-api-key", + config: { + // Options for LLM Provider + }, + // Optional Mem0 Global Config + mem0Config: { + user_id: "mem0-user-id", + }, + }); + ``` + + > **Note**: The `openai` provider is set as default. Consider using `MEM0_API_KEY` and `OPENAI_API_KEY` as environment variables for security. + + > **Note**: The `mem0Config` is optional. It is used to set the global config for the Mem0 Client (eg. `user_id`, `agent_id`, `app_id`, `run_id`, `org_id`, `project_id` etc). + +3. Add Memories to Enhance Context: + + ```typescript + import { LanguageModelV2Prompt } from "@ai-sdk/provider"; + import { addMemories } from "@mem0/vercel-ai-provider"; + + const messages: LanguageModelV2Prompt = [ + { role: "user", content: [{ type: "text", text: "I love red cars." }] }, + ]; + + await addMemories(messages, { user_id: "borat" }); + ``` + +### Standalone Features: + + ```typescript + await addMemories(messages, { user_id: "borat", mem0ApiKey: "m0-xxx" }); + await retrieveMemories(prompt, { user_id: "borat", mem0ApiKey: "m0-xxx" }); + await getMemories(prompt, { user_id: "borat", mem0ApiKey: "m0-xxx" }); + ``` + > For standalone features, such as `addMemories`, `retrieveMemories`, and `getMemories`, you must either set `MEM0_API_KEY` as an environment variable or pass it directly in the function call. + + > `getMemories` will return raw memories in the form of an array of objects, while `retrieveMemories` will return a response in string format with a system prompt ingested with the retrieved memories. + + > `getMemories` is an object with two keys: `results` and `relations` if `enable_graph` is enabled. Otherwise, it will return an array of objects. + +### 1. Basic Text Generation with Memory Context + + ```typescript + import { generateText } from "ai"; + import { createMem0 } from "@mem0/vercel-ai-provider"; + + const mem0 = createMem0(); + + const { text } = await generateText({ + model: mem0("gpt-4-turbo", { user_id: "borat" }), + prompt: "Suggest me a good car to buy!", + }); + ``` + +### 2. Combining OpenAI Provider with Memory Utils + + ```typescript + import { generateText } from "ai"; + import { openai } from "@ai-sdk/openai"; + import { retrieveMemories } from "@mem0/vercel-ai-provider"; + + const prompt = "Suggest me a good car to buy."; + const memories = await retrieveMemories(prompt, { user_id: "borat" }); + + const { text } = await generateText({ + model: openai("gpt-4-turbo"), + prompt: prompt, + system: memories, + }); + ``` + +### 3. Structured Message Format with Memory + + ```typescript + import { generateText } from "ai"; + import { createMem0 } from "@mem0/vercel-ai-provider"; + + const mem0 = createMem0(); + + const { text } = await generateText({ + model: mem0("gpt-4-turbo", { user_id: "borat" }), + messages: [ + { + role: "user", + content: [ + { type: "text", text: "Suggest me a good car to buy." }, + { type: "text", text: "Why is it better than the other cars for me?" }, + ], + }, + ], + }); + ``` + +### 3. Streaming Responses with Memory Context + + ```typescript + import { streamText } from "ai"; + import { createMem0 } from "@mem0/vercel-ai-provider"; + + const mem0 = createMem0(); + + const { textStream } = streamText({ + model: mem0("gpt-4-turbo", { + user_id: "borat", + }), + prompt: "Suggest me a good car to buy! Why is it better than the other cars for me? Give options for every price range.", + }); + + for await (const textPart of textStream) { + process.stdout.write(textPart); + } + ``` + +### 4. Generate Responses with Tools Call + + ```typescript + import { generateText } from "ai"; + import { createMem0 } from "@mem0/vercel-ai-provider"; + import { z } from "zod"; + + const mem0 = createMem0({ + provider: "anthropic", + apiKey: "anthropic-api-key", + mem0Config: { + // Global User ID + user_id: "borat" + } + }); + + const prompt = "What the temperature in the city that I live in?" + + const result = await generateText({ + model: mem0('claude-3-5-sonnet-20240620'), + tools: { + weather: tool({ + description: 'Get the weather in a location', + parameters: z.object({ + location: z.string().describe('The location to get the weather for'), + }), + execute: async ({ location }) => ({ + location, + temperature: 72 + Math.floor(Math.random() * 21) - 10, + }), + }), + }, + prompt: prompt, + }); + + console.log(result); + ``` + +### 5. Get sources from memory + +```typescript +const { text, sources } = await generateText({ + model: mem0("gpt-4-turbo"), + prompt: "Suggest me a good car to buy!", +}); + +console.log(sources); +``` + +The same can be done for `streamText` as well. + +## Graph Memory + +Mem0 AI SDK now supports Graph Memory. You can enable it by setting `enable_graph` to `true` in the `mem0Config` object. + +```typescript +const mem0 = createMem0({ + mem0Config: { enable_graph: true }, +}); +``` + +You can also pass `enable_graph` in the standalone functions. This includes `getMemories`, `retrieveMemories`, and `addMemories`. + +```typescript +const memories = await getMemories(prompt, { user_id: "borat", mem0ApiKey: "m0-xxx", enable_graph: true }); +``` + +The `getMemories` function will return an object with two keys: `results` and `relations`, if `enable_graph` is set to `true`. Otherwise, it will return an array of objects. + +## Supported LLM Providers + +| Provider | Configuration Value | +|----------|-------------------| +| OpenAI | openai | +| Anthropic | anthropic | +| Google | google | +| Groq | groq | + +> **Note**: You can use `google` as provider for Gemini (Google) models. They are same and internally they use `@ai-sdk/google` package. + +## Key Features + +- `createMem0()`: Initializes a new Mem0 provider instance. +- `retrieveMemories()`: Retrieves memory context for prompts. +- `getMemories()`: Get memories from your profile in array format. +- `addMemories()`: Adds user memories to enhance contextual responses. + +## Best Practices + +1. **User Identification**: Use a unique `user_id` for consistent memory retrieval. +2. **Memory Cleanup**: Regularly clean up unused memory data. + + > **Note**: We also have support for `agent_id`, `app_id`, and `run_id`. Refer [Docs](/api-reference/memory/add-memories). + +## Conclusion + +Mem0’s Vercel AI SDK enables the creation of intelligent, context-aware applications with persistent memory and seamless integration. + +## Help + +- For more details on Vercel AI SDK, visit the [Vercel AI SDK documentation](https://sdk.vercel.ai/docs/introduction) +- [Mem0 Platform](https://app.mem0.ai/) +- If you need further assistance, please feel free to reach out to us through following methods: + + \ No newline at end of file diff --git a/docs/v0x/introduction.mdx b/docs/v0x/introduction.mdx new file mode 100644 index 000000000..8b0fe9b45 --- /dev/null +++ b/docs/v0x/introduction.mdx @@ -0,0 +1,98 @@ +--- +title: Introduction to Mem0 v0.x +description: 'Legacy documentation for Mem0 version 0.x' +icon: "book-open" +iconType: "solid" +--- + + +**This is legacy documentation for Mem0 v0.x.** For the latest features and improvements, please refer to [v1.0 Beta documentation](/). + + +## Welcome to Mem0 v0.x + +Mem0 (pronounced "mem-zero") is a self-improving memory layer for Large Language Models, enabling developers to create personalized AI experiences that save costs and delight users. + +## What is Mem0? + +Mem0 provides an intelligent, adaptive memory system that learns and evolves with each interaction. Unlike traditional RAG approaches that rely on static embeddings, Mem0's memory system understands context, relationships, and user preferences to deliver truly personalized experiences. + +### Key Features (v0.x) + +- **Adaptive Learning**: Memory that improves with each user interaction +- **Cross-Platform**: Python and JavaScript SDKs +- **Flexible Integration**: Works with any LLM and vector database +- **User Personalization**: Learns individual user preferences and patterns +- **Developer Friendly**: Simple APIs with powerful customization options + +## How Mem0 Works + +```python +from mem0 import Memory + +# Initialize memory +m = Memory() + +# Add memories +m.add("I am working on improving my tennis skills. Suggest some online courses.", user_id="alice") + +# Query memories +results = m.search("What can you tell me about alice?", user_id="alice") +# Returns: "Alice is working on improving her tennis skills and is interested in online courses" +``` + +## Getting Started + + + + Get up and running with Mem0 in minutes + + + Understand how Mem0's memory system works + + + +## Use Cases + +- **Personalized AI Assistants**: Create assistants that remember user preferences and context +- **Customer Support**: Build systems that recall previous interactions and issues +- **Educational Platforms**: Develop tutors that adapt to individual learning styles +- **Content Recommendation**: Generate suggestions based on historical preferences +- **Healthcare Applications**: Maintain patient interaction history and preferences + +## Memory Persistence + +In v0.x, memories are automatically stored and persist across sessions: + +```python +# Session 1 +m.add("I prefer vegetarian restaurants", user_id="alice") + +# Session 2 (later) +results = m.search("restaurant recommendations", user_id="alice") +# Automatically considers vegetarian preference +``` + +## Platform vs Open Source + +### Mem0 Platform (Managed) +- Hosted solution with enhanced features +- Enterprise-grade reliability and security +- Advanced analytics and monitoring +- Team collaboration features + +### Mem0 Open Source +- Self-hosted deployment +- Full customization control +- Community-driven development +- Free for personal and commercial use + +## Next Steps + +1. **Try the Quickstart**: Follow our [quickstart guide](/v0x/quickstart) to build your first memory-enabled application +2. **Explore Examples**: Check out our practical examples and use cases +3. **Join the Community**: Connect with other developers building with Mem0 + + +**Need to migrate to v1.0?** Check out our [migration guide](/migration/v0-to-v1) for step-by-step instructions. + \ No newline at end of file diff --git a/docs/v0x/open-source/node-quickstart.mdx b/docs/v0x/open-source/node-quickstart.mdx new file mode 100644 index 000000000..8b6ea60d8 --- /dev/null +++ b/docs/v0x/open-source/node-quickstart.mdx @@ -0,0 +1,455 @@ +--- +title: Node SDK Quickstart +description: 'Get started with Mem0 quickly!' +icon: "node" +iconType: "solid" +--- + +> Welcome to the Mem0 quickstart guide. This guide will help you get up and running with Mem0 in no time. + +## Installation + +To install Mem0, you can use npm. Run the following command in your terminal: + +```bash +npm install mem0ai +``` + +## Basic Usage + +### Initialize Mem0 + + + +```typescript +import { Memory } from 'mem0ai/oss'; + +const memory = new Memory(); +``` + + +If you want to run Mem0 in production, initialize using the following method: + +```typescript +import { Memory } from 'mem0ai/oss'; + +const memory = new Memory({ + version: 'v1.1', + embedder: { + provider: 'openai', + config: { + apiKey: process.env.OPENAI_API_KEY || '', + model: 'text-embedding-3-small', + }, + }, + vectorStore: { + provider: 'memory', + config: { + collectionName: 'memories', + dimension: 1536, + }, + }, + llm: { + provider: 'openai', + config: { + apiKey: process.env.OPENAI_API_KEY || '', + model: 'gpt-4-turbo-preview', + }, + }, + historyDbPath: 'memory.db', + }); +``` + + + + +### Store a Memory + + +```typescript Code +const messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] + +await memory.add(messages, { userId: "alice", metadata: { category: "movie_recommendations" } }); +``` + +```json Output +{ + "results": [ + { + "id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e", + "memory": "User is planning to watch a movie tonight.", + "metadata": { + "category": "movie_recommendations" + } + }, + { + "id": "cbb1fe73-0bf1-4067-8c1f-63aa53e7b1a4", + "memory": "User is not a big fan of thriller movies.", + "metadata": { + "category": "movie_recommendations" + } + }, + { + "id": "475bde34-21e6-42ab-8bef-0ab84474f156", + "memory": "User loves sci-fi movies.", + "metadata": { + "category": "movie_recommendations" + } + } + ] +} +``` + + +### Retrieve Memories + + +```typescript Code +// Get all memories +const allMemories = await memory.getAll({ userId: "alice" }); +console.log(allMemories) +``` + +```json Output +{ + "results": [ + { + "id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e", + "memory": "User is planning to watch a movie tonight.", + "hash": "1a271c007316c94377175ee80e746a19", + "createdAt": "2025-02-27T16:33:20.557Z", + "updatedAt": "2025-02-27T16:33:27.051Z", + "metadata": { + "category": "movie_recommendations" + }, + "userId": "alice" + }, + { + "id": "475bde34-21e6-42ab-8bef-0ab84474f156", + "memory": "User loves sci-fi movies.", + "hash": "285d07801ae42054732314853e9eadd7", + "createdAt": "2025-02-27T16:33:20.560Z", + "updatedAt": undefined, + "metadata": { + "category": "movie_recommendations" + }, + "userId": "alice" + }, + { + "id": "cbb1fe73-0bf1-4067-8c1f-63aa53e7b1a4", + "memory": "User is not a big fan of thriller movies.", + "hash": "285d07801ae42054732314853e9eadd7", + "createdAt": "2025-02-27T16:33:20.560Z", + "updatedAt": undefined, + "metadata": { + "category": "movie_recommendations" + }, + "userId": "alice" + } + ] +} +``` + + + +
+ + +```typescript Code +// Get a single memory by ID +const singleMemory = await memory.get('892db2ae-06d9-49e5-8b3e-585ef9b85b8e'); +console.log(singleMemory); +``` + +```json Output +{ + "id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e", + "memory": "User is planning to watch a movie tonight.", + "hash": "1a271c007316c94377175ee80e746a19", + "createdAt": "2025-02-27T16:33:20.557Z", + "updatedAt": undefined, + "metadata": { + "category": "movie_recommendations" + }, + "userId": "alice" +} +``` + + +### Search Memories + + +```typescript Code +const result = await memory.search('What do you know about me?', { userId: "alice" }); +console.log(result); +``` + +```json Output +{ + "results": [ + { + "id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e", + "memory": "User is planning to watch a movie tonight.", + "hash": "1a271c007316c94377175ee80e746a19", + "createdAt": "2025-02-27T16:33:20.557Z", + "updatedAt": undefined, + "score": 0.38920719231944799, + "metadata": { + "category": "movie_recommendations" + }, + "userId": "alice" + }, + { + "id": "475bde34-21e6-42ab-8bef-0ab84474f156", + "memory": "User loves sci-fi movies.", + "hash": "285d07801ae42054732314853e9eadd7", + "createdAt": "2025-02-27T16:33:20.560Z", + "updatedAt": undefined, + "score": 0.36869761478135689, + "metadata": { + "category": "movie_recommendations" + }, + "userId": "alice" + }, + { + "id": "cbb1fe73-0bf1-4067-8c1f-63aa53e7b1a4", + "memory": "User is not a big fan of thriller movies.", + "hash": "285d07801ae42054732314853e9eadd7", + "createdAt": "2025-02-27T16:33:20.560Z", + "updatedAt": undefined, + "score": 0.33855272141248272, + "metadata": { + "category": "movie_recommendations" + }, + "userId": "alice" + } + ] +} +``` + + +### Update a Memory + + +```typescript Code +const result = await memory.update( + '892db2ae-06d9-49e5-8b3e-585ef9b85b8e', + 'I love India, it is my favorite country.' +); +console.log(result); +``` + +```json Output +{ + "message": "Memory updated successfully!" +} +``` + + +### Memory History + + +```typescript Code +const history = await memory.history('892db2ae-06d9-49e5-8b3e-585ef9b85b8e'); +console.log(history); +``` + +```json Output +[ + { + "id": 39, + "memoryId": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e", + "previousValue": "User is planning to watch a movie tonight.", + "newValue": "I love India, it is my favorite country.", + "action": "UPDATE", + "createdAt": "2025-02-27T16:33:20.557Z", + "updatedAt": "2025-02-27T16:33:27.051Z", + "isDeleted": 0 + }, + { + "id": 37, + "memoryId": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e", + "previousValue": null, + "newValue": "User is planning to watch a movie tonight.", + "action": "ADD", + "createdAt": "2025-02-27T16:33:20.557Z", + "updatedAt": null, + "isDeleted": 0 + } +] +``` + + +### Delete Memory + +```typescript +// Delete a memory by id +await memory.delete('892db2ae-06d9-49e5-8b3e-585ef9b85b8e'); + +// Delete all memories for a user +await memory.deleteAll({ userId: "alice" }); +``` + +### Reset Memory + +```typescript +await memory.reset(); // Reset all memories +``` + +### History Store + +Mem0 TypeScript SDK support history stores to run on a serverless environment: + +We recommend using `Supabase` as a history store for serverless environments or disable history store to run on a serverless environment. + + +```typescript Supabase +import { Memory } from 'mem0ai/oss'; + +const memory = new Memory({ + historyStore: { + provider: 'supabase', + config: { + supabaseUrl: process.env.SUPABASE_URL || '', + supabaseKey: process.env.SUPABASE_KEY || '', + tableName: 'memory_history', + }, + }, +}); +``` + +```typescript Disable History +import { Memory } from 'mem0ai/oss'; + +const memory = new Memory({ + disableHistory: true, +}); +``` + + +Mem0 uses SQLite as a default history store. + +#### Create Memory History Table in Supabase + +You may need to create a memory history table in Supabase to store the history of memories. Use the following SQL command in `SQL Editor` on the Supabase project dashboard to create a memory history table: + +```sql +create table memory_history ( + id text primary key, + memory_id text not null, + previous_value text, + new_value text, + action text not null, + created_at timestamp with time zone default timezone('utc', now()), + updated_at timestamp with time zone, + is_deleted integer default 0 +); +``` + +## Configuration Parameters + +Mem0 offers extensive configuration options to customize its behavior according to your needs. These configurations span across different components like vector stores, language models, embedders, and graph stores. + + + +| Parameter | Description | Default | +|-------------|---------------------------------|-------------| +| `provider` | Vector store provider (e.g., "memory") | "memory" | +| `host` | Host address | "localhost" | +| `port` | Port number | undefined | + + + +| Parameter | Description | Provider | +|-----------------------|-----------------------------------------------|-------------------| +| `provider` | LLM provider (e.g., "openai", "anthropic") | All | +| `model` | Model to use | All | +| `temperature` | Temperature of the model | All | +| `apiKey` | API key to use | All | +| `maxTokens` | Tokens to generate | All | +| `topP` | Probability threshold for nucleus sampling | All | +| `topK` | Number of highest probability tokens to keep | All | +| `openaiBaseUrl` | Base URL for OpenAI API | OpenAI | + + + +| Parameter | Description | Default | +|-------------|---------------------------------|-------------| +| `provider` | Graph store provider (e.g., "neo4j") | "neo4j" | +| `url` | Connection URL | env.NEO4J_URL | +| `username` | Authentication username | env.NEO4J_USERNAME | +| `password` | Authentication password | env.NEO4J_PASSWORD | + + + +| Parameter | Description | Default | +|-------------|---------------------------------|------------------------------| +| `provider` | Embedding provider | "openai" | +| `model` | Embedding model to use | "text-embedding-3-small" | +| `apiKey` | API key for embedding service | None | + + + +| Parameter | Description | Default | +|------------------|--------------------------------------|----------------------------| +| `historyDbPath` | Path to the history database | "{mem0_dir}/history.db" | +| `version` | API version | "v1.0" | +| `customPrompt` | Custom prompt for memory processing | None | + + + +| Parameter | Description | Default | +|------------------|--------------------------------------|----------------------------| +| `provider` | History store provider | "sqlite" | +| `config` | History store configuration | None (Defaults to SQLite) | +| `disableHistory` | Disable history store | false | + + + +```typescript +const config = { + version: 'v1.1', + embedder: { + provider: 'openai', + config: { + apiKey: process.env.OPENAI_API_KEY || '', + model: 'text-embedding-3-small', + }, + }, + vectorStore: { + provider: 'memory', + config: { + collectionName: 'memories', + dimension: 1536, + }, + }, + llm: { + provider: 'openai', + config: { + apiKey: process.env.OPENAI_API_KEY || '', + model: 'gpt-4-turbo-preview', + }, + }, + historyStore: { + provider: 'supabase', + config: { + supabaseUrl: process.env.SUPABASE_URL || '', + supabaseKey: process.env.SUPABASE_KEY || '', + tableName: 'memories', + }, + }, + disableHistory: false, // This is false by default + customPrompt: "I'm a virtual assistant. I'm here to help you with your queries.", + } +``` + + + +If you have any questions, please feel free to reach out to us using one of the following methods: + + \ No newline at end of file diff --git a/docs/v0x/open-source/overview.mdx b/docs/v0x/open-source/overview.mdx new file mode 100644 index 000000000..c060b70c9 --- /dev/null +++ b/docs/v0x/open-source/overview.mdx @@ -0,0 +1,28 @@ +--- +title: Overview +icon: "eye" +iconType: "solid" +--- + +Welcome to Mem0 Open Source - a powerful, self-hosted memory management solution for AI agents and assistants. With Mem0 OSS, you get full control over your infrastructure while maintaining complete customization flexibility. + +We offer two SDKs for Python and Node.js. + +Check out our [GitHub repository](https://mem0.dev/gd) to explore the source code. + + + + Learn more about Mem0 OSS Python SDK + + + Learn more about Mem0 OSS Node.js SDK + + + +## Key Features + +- **Full Infrastructure Control**: Host Mem0 on your own servers +- **Customizable Implementation**: Modify and extend functionality as needed +- **Local Development**: Perfect for development and testing +- **No Vendor Lock-in**: Own your data and infrastructure +- **Community Driven**: Benefit from and contribute to community improvements diff --git a/docs/v0x/open-source/python-quickstart.mdx b/docs/v0x/open-source/python-quickstart.mdx new file mode 100644 index 000000000..622310ef7 --- /dev/null +++ b/docs/v0x/open-source/python-quickstart.mdx @@ -0,0 +1,546 @@ +--- +title: Python SDK Quickstart +description: 'Get started with Mem0 quickly!' +icon: "python" +iconType: "solid" +--- + +> Welcome to the Mem0 quickstart guide. This guide will help you get up and running with Mem0 in no time. + +## Installation + +To install Mem0, you can use pip. Run the following command in your terminal: + +```bash +pip install mem0ai +``` + +## Basic Usage + +### Initialize Mem0 + + + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" + +m = Memory() +``` + + +```python +import os +from mem0 import AsyncMemory + +os.environ["OPENAI_API_KEY"] = "your-api-key" + +m = AsyncMemory() +``` + + +If you want to run Mem0 in production, initialize using the following method: + +Run Qdrant first: + +```bash +docker pull qdrant/qdrant + +docker run -p 6333:6333 -p 6334:6334 \ + -v $(pwd)/qdrant_storage:/qdrant/storage:z \ + qdrant/qdrant +``` + +Then, instantiate memory with qdrant server: + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" + +config = { + "vector_store": { + "provider": "qdrant", + "config": { + "host": "localhost", + "port": 6333, + } + }, +} + +m = Memory.from_config(config) +``` + + + + +```python +import os +from mem0 import Memory + +os.environ["OPENAI_API_KEY"] = "your-api-key" + +config = { + "graph_store": { + "provider": "neo4j", + "config": { + "url": "neo4j+s://---", + "username": "neo4j", + "password": "---" + } + } +} + +m = Memory.from_config(config_dict=config) +``` + + + + + +### Store a Memory + + +```python Code +messages = [ + {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"}, + {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."}, + {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."}, + {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."} +] + +# Store inferred memories (default behavior) +result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"}) + +# Store memories with agent and run context +result = m.add(messages, user_id="alice", agent_id="movie-assistant", run_id="session-001", metadata={"category": "movie_recommendations"}) + +# Store raw messages without inference +# result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"}, infer=False) +``` + +```json Output +{ + "results": [ + { + "id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e", + "memory": "User is planning to watch a movie tonight.", + "metadata": { + "category": "movie_recommendations" + }, + "event": "ADD" + }, + { + "id": "cbb1fe73-0bf1-4067-8c1f-63aa53e7b1a4", + "memory": "User is not a big fan of thriller movies.", + "metadata": { + "category": "movie_recommendations" + }, + "event": "ADD" + }, + { + "id": "475bde34-21e6-42ab-8bef-0ab84474f156", + "memory": "User loves sci-fi movies.", + "metadata": { + "category": "movie_recommendations" + }, + "event": "ADD" + } + ] +} +``` + + +### Retrieve Memories + + +```python Code +# Get all memories +all_memories = m.get_all(user_id="alice") +``` + +```json Output +{ + "results": [ + { + "id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e", + "memory": "User is planning to watch a movie tonight.", + "hash": "1a271c007316c94377175ee80e746a19", + "created_at": "2025-02-27T16:33:20.557Z", + "updated_at": "2025-02-27T16:33:27.051Z", + "metadata": { + "category": "movie_recommendations" + }, + "user_id": "alice" + }, + { + "id": "475bde34-21e6-42ab-8bef-0ab84474f156", + "memory": "User loves sci-fi movies.", + "hash": "285d07801ae42054732314853e9eadd7", + "created_at": "2025-02-27T16:33:20.560Z", + "updated_at": None, + "metadata": { + "category": "movie_recommendations" + }, + "user_id": "alice" + }, + { + "id": "cbb1fe73-0bf1-4067-8c1f-63aa53e7b1a4", + "memory": "User is not a big fan of thriller movies.", + "hash": "285d07801ae42054732314853e9eadd7", + "created_at": "2025-02-27T16:33:20.560Z", + "updated_at": None, + "metadata": { + "category": "movie_recommendations" + }, + "user_id": "alice" + } + ] +} +``` + + + +
+ + +```python Code +# Get a single memory by ID +specific_memory = m.get("892db2ae-06d9-49e5-8b3e-585ef9b85b8e") +``` + +```json Output +{ + "id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e", + "memory": "User is planning to watch a movie tonight.", + "hash": "1a271c007316c94377175ee80e746a19", + "created_at": "2025-02-27T16:33:20.557Z", + "updated_at": None, + "metadata": { + "category": "movie_recommendations" + }, + "user_id": "alice" +} +``` + + +### Search Memories + + +```python Code +related_memories = m.search(query="What do you know about me?", user_id="alice") +``` + +```json Output +{ + "results": [ + { + "id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e", + "memory": "User is planning to watch a movie tonight.", + "hash": "1a271c007316c94377175ee80e746a19", + "created_at": "2025-02-27T16:33:20.557Z", + "updated_at": None, + "score": 0.38920719231944799, + "metadata": { + "category": "movie_recommendations" + }, + "user_id": "alice" + }, + { + "id": "475bde34-21e6-42ab-8bef-0ab84474f156", + "memory": "User loves sci-fi movies.", + "hash": "285d07801ae42054732314853e9eadd7", + "created_at": "2025-02-27T16:33:20.560Z", + "updated_at": None, + "score": 0.36869761478135689, + "metadata": { + "category": "movie_recommendations" + }, + "user_id": "alice" + }, + { + "id": "cbb1fe73-0bf1-4067-8c1f-63aa53e7b1a4", + "memory": "User is not a big fan of thriller movies.", + "hash": "285d07801ae42054732314853e9eadd7", + "created_at": "2025-02-27T16:33:20.560Z", + "updated_at": None, + "score": 0.33855272141248272, + "metadata": { + "category": "movie_recommendations" + }, + "user_id": "alice" + } + ] +} +``` + + +### Update a Memory + + +```python Code +result = m.update(memory_id="892db2ae-06d9-49e5-8b3e-585ef9b85b8e", data="I love India, it is my favorite country.") +``` + +```json Output +{'message': 'Memory updated successfully!'} +``` + + +### Memory History + + +```python Code +history = m.history(memory_id="892db2ae-06d9-49e5-8b3e-585ef9b85b8e") +``` + +```json Output +[ + { + "id": 39, + "memory_id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e", + "previous_value": "User is planning to watch a movie tonight.", + "new_value": "I love India, it is my favorite country.", + "action": "UPDATE", + "created_at": "2025-02-27T16:33:20.557Z", + "updated_at": "2025-02-27T16:33:27.051Z", + "is_deleted": 0 + }, + { + "id": 37, + "memory_id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e", + "previous_value": null, + "new_value": "User is planning to watch a movie tonight.", + "action": "ADD", + "created_at": "2025-02-27T16:33:20.557Z", + "updated_at": null, + "is_deleted": 0 + } +] +``` + + +### Delete Memory + +```python +# Delete a memory by id +m.delete(memory_id="892db2ae-06d9-49e5-8b3e-585ef9b85b8e") +# Delete all memories for a user +m.delete_all(user_id="alice") +``` + +### Reset Memory + +```python +m.reset() # Reset all memories +``` + +## Advanced Memory Organization + +Mem0 supports three key parameters for organizing memories: + +- **`user_id`**: Organize memories by user identity +- **`agent_id`**: Organize memories by AI agent or assistant +- **`run_id`**: Organize memories by session, workflow, or execution context + +### Using All Three Parameters + +```python +# Store memories with full context +m.add("User prefers vegetarian food", + user_id="alice", + agent_id="diet-assistant", + run_id="consultation-001") + +# Retrieve memories with different scopes +all_user_memories = m.get_all(user_id="alice") +agent_memories = m.get_all(user_id="alice", agent_id="diet-assistant") +session_memories = m.get_all(user_id="alice", run_id="consultation-001") +specific_memories = m.get_all(user_id="alice", agent_id="diet-assistant", run_id="consultation-001") + +# Search with context +general_search = m.search("What do you know about me?", user_id="alice") +agent_search = m.search("What do you know about me?", user_id="alice", agent_id="diet-assistant") +session_search = m.search("What do you know about me?", user_id="alice", run_id="consultation-001") +``` + +## Configuration Parameters + +Mem0 offers extensive configuration options to customize its behavior according to your needs. These configurations span across different components like vector stores, language models, embedders, and graph stores. + + + +| Parameter | Description | Default | +|-------------|---------------------------------|-------------| +| `provider` | Vector store provider (e.g., "qdrant") | "qdrant" | +| `host` | Host address | "localhost" | +| `port` | Port number | 6333 | + + + +| Parameter | Description | Provider | +|-----------------------|-----------------------------------------------|-------------------| +| `provider` | LLM provider (e.g., "openai", "anthropic") | All | +| `model` | Model to use | All | +| `temperature` | Temperature of the model | All | +| `api_key` | API key to use | All | +| `max_tokens` | Tokens to generate | All | +| `top_p` | Probability threshold for nucleus sampling | All | +| `top_k` | Number of highest probability tokens to keep | All | +| `http_client_proxies` | Allow proxy server settings | AzureOpenAI | +| `models` | List of models | Openrouter | +| `route` | Routing strategy | Openrouter | +| `openrouter_base_url` | Base URL for Openrouter API | Openrouter | +| `site_url` | Site URL | Openrouter | +| `app_name` | Application name | Openrouter | +| `ollama_base_url` | Base URL for Ollama API | Ollama | +| `openai_base_url` | Base URL for OpenAI API | OpenAI | +| `azure_kwargs` | Azure LLM args for initialization | AzureOpenAI | +| `deepseek_base_url` | Base URL for DeepSeek API | DeepSeek | + + + +| Parameter | Description | Default | +|-------------|---------------------------------|------------------------------| +| `provider` | Embedding provider | "openai" | +| `model` | Embedding model to use | "text-embedding-3-small" | +| `api_key` | API key for embedding service | None | + + + +| Parameter | Description | Default | +|-------------|---------------------------------|-------------| +| `provider` | Graph store provider (e.g., "neo4j") | "neo4j" | +| `url` | Connection URL | None | +| `username` | Authentication username | None | +| `password` | Authentication password | None | + + + +| Parameter | Description | Default | +|------------------|--------------------------------------|----------------------------| +| `history_db_path` | Path to the history database | "{mem0_dir}/history.db" | +| `version` | API version | "v1.1" | +| `custom_fact_extraction_prompt` | Custom prompt for memory processing | None | +| `custom_update_memory_prompt` | Custom prompt for update memory | None | + + + +```python +config = { + "vector_store": { + "provider": "qdrant", + "config": { + "host": "localhost", + "port": 6333 + } + }, + "llm": { + "provider": "openai", + "config": { + "api_key": "your-api-key", + "model": "gpt-4" + } + }, + "embedder": { + "provider": "openai", + "config": { + "api_key": "your-api-key", + "model": "text-embedding-3-small" + } + }, + "graph_store": { + "provider": "neo4j", + "config": { + "url": "neo4j+s://your-instance", + "username": "neo4j", + "password": "password" + } + }, + "history_db_path": "/path/to/history.db", + "version": "v1.1", + "custom_fact_extraction_prompt": "Optional custom prompt for fact extraction for memory", + "custom_update_memory_prompt": "Optional custom prompt for update memory" +} +``` + + + +## Run Mem0 Locally + +Please refer to the example [Mem0 with Ollama](../examples/mem0-with-ollama) to run Mem0 locally. + + +## Chat Completion + +Mem0 can be easily integrated into chat applications to enhance conversational agents with structured memory. Mem0's APIs are designed to be compatible with OpenAI's, with the goal of making it easy to leverage Mem0 in applications you may have already built. + +If you have a `Mem0 API key`, you can use it to initialize the client. Alternatively, you can initialize Mem0 without an API key if you're using it locally. + +Mem0 supports several language models (LLMs) through integration with various [providers](https://litellm.vercel.app/docs/providers). + +## Use Mem0 OSS + +```python +config = { + "vector_store": { + "provider": "qdrant", + "config": { + "host": "localhost", + "port": 6333, + } + }, +} + +client = Mem0(config=config) + +chat_completion = client.chat.completions.create( + messages=[ + { + "role": "user", + "content": "What's the capital of France?", + } + ], + model="gpt-4o", +) +``` + +## Contributing + +We welcome contributions to Mem0! Here's how you can contribute: + +1. Fork the repository and create your branch from `main`. +2. Clone the forked repository to your local machine. +3. Install the project dependencies: + + ```bash + poetry install + ``` + +4. Install pre-commit hooks: + + ```bash + pip install pre-commit # If pre-commit is not already installed + pre-commit install + ``` + +5. Make your changes and ensure they adhere to the project's coding standards. + +6. Run the tests locally: + + ```bash + poetry run pytest + ``` + +7. If all tests pass, commit your changes and push to your fork. +8. Open a pull request with a clear title and description. + +Please make sure your code follows our coding conventions and is well-documented. We appreciate your contributions to make Mem0 better! + + +If you have any questions, please feel free to reach out to us using one of the following methods: + + \ No newline at end of file diff --git a/docs/v0x/quickstart.mdx b/docs/v0x/quickstart.mdx new file mode 100644 index 000000000..29b4d4329 --- /dev/null +++ b/docs/v0x/quickstart.mdx @@ -0,0 +1,246 @@ +--- +title: Quickstart (v0.x) +description: 'Get started with Mem0 v0.x quickly' +icon: "bolt" +iconType: "solid" +--- + + +**This is legacy documentation for Mem0 v0.x.** For the latest features, please refer to [v1.0 Beta documentation](/quickstart). + + +## Installation + +```bash +pip install mem0ai==0.1.20 # Last stable v0.x version +``` + +## Basic Usage + +### Initialize Mem0 + +```python +from mem0 import Memory +import os + +# Set your OpenAI API key +os.environ["OPENAI_API_KEY"] = "your-api-key" + +# Initialize memory +m = Memory() +``` + +### Add Memories + +```python +# Add a simple memory +result = m.add("I love pizza and prefer thin crust", user_id="alice") +print(result) +``` + +**Response Format (v0.x):** +```json +[ + { + "id": "mem_123", + "memory": "User loves pizza and prefers thin crust", + "event": "ADD" + } +] +``` + +### Search Memories + +```python +# Search for relevant memories +results = m.search("What food does alice like?", user_id="alice") +print(results) +``` + +**Response Format (v0.x):** +```json +[ + { + "id": "mem_123", + "memory": "User loves pizza and prefers thin crust", + "score": 0.95, + "user_id": "alice" + } +] +``` + +### Get All Memories + +```python +# Get all memories for a user +all_memories = m.get_all(user_id="alice") +print(all_memories) +``` + +## Configuration (v0.x) + +### Basic Configuration + +```python +config = { + "vector_store": { + "provider": "qdrant", + "config": { + "host": "localhost", + "port": 6333 + } + }, + "llm": { + "provider": "openai", + "config": { + "model": "gpt-3.5-turbo", + "api_key": "your-api-key" + } + }, + "version": "v1.0" # Supported in v0.x +} + +m = Memory.from_config(config) +``` + +### Supported Parameters (v0.x) + +| Parameter | Type | Description | v0.x Support | +|-----------|------|-------------|--------------| +| `output_format` | str | Response format ("v1.0" or "v1.1") | ✅ Yes | +| `version` | str | API version | ✅ Yes | +| `async_mode` | bool | Enable async processing | ✅ Optional | + +## API Differences + +### v0.x Features + +#### 1. Output Format Control +```python +# v0.x supports output_format parameter +result = m.add( + "I love hiking", + user_id="alice", + output_format="v1.0" # Available in v0.x +) +``` + +#### 2. Version Parameter +```python +# v0.x supports version configuration +config = { + "version": "v1.0" # Explicit version setting +} +``` + +#### 3. Optional Async Mode +```python +# v0.x: Async is optional +result = m.add( + "memory content", + user_id="alice", + async_mode=False # Synchronous by default +) +``` + +### Response Formats + +#### v1.0 Format (v0.x default) +```python +result = m.add("I love coffee", user_id="alice", output_format="v1.0") +# Returns: [{"id": "...", "memory": "...", "event": "ADD"}] +``` + +#### v1.1 Format (v0.x optional) +```python +result = m.add("I love coffee", user_id="alice", output_format="v1.1") +# Returns: {"results": [{"id": "...", "memory": "...", "event": "ADD"}]} +``` + +## Limitations in v0.x + +- No reranking support +- Basic metadata filtering only +- Limited async optimization +- No enhanced prompt features +- No advanced memory operations + +## Migration Path + +To upgrade to v1.0 Beta: + +1. **Remove deprecated parameters:** + ```python + # Old (v0.x) + m.add("memory", user_id="alice", output_format="v1.0", version="v1.0") + + # New (v1.0 Beta) + m.add("memory", user_id="alice") + ``` + +2. **Update response handling:** + ```python + # Old (v0.x) + result = m.add("memory", user_id="alice") + if isinstance(result, list): + for item in result: + print(item["memory"]) + + # New (v1.0 Beta) + result = m.add("memory", user_id="alice") + for item in result["results"]: + print(item["memory"]) + ``` + +3. **Upgrade installation:** + ```bash + pip install --upgrade mem0ai + ``` + +## Examples + +### Personal Assistant + +```python +from mem0 import Memory + +m = Memory() + +# Learn user preferences +m.add("I prefer morning meetings and dislike late evening calls", user_id="john") +m.add("I'm vegetarian and allergic to nuts", user_id="john") + +# Query for personalized responses +schedule_pref = m.search("when does john prefer meetings?", user_id="john") +food_pref = m.search("what food restrictions does john have?", user_id="john") + +print("Schedule:", schedule_pref[0]["memory"]) +print("Food:", food_pref[0]["memory"]) +``` + +### Customer Support + +```python +# Track customer interactions +m.add("Customer reported login issues with Safari browser", user_id="customer_123") +m.add("Resolved login issue by clearing browser cache", user_id="customer_123") + +# Later interaction +history = m.search("previous issues", user_id="customer_123") +print("Previous context:", history) +``` + +## Next Steps + + + + Understand memory types and operations + + + Self-host Mem0 with full control + + + + +**Ready to upgrade?** Check out the [migration guide](/migration/v0-to-v1) to move to v1.0 Beta and access new features like reranking and enhanced filtering. + \ No newline at end of file