Skip to main content
Build AI applications with persistent memory and comprehensive LLM observability by integrating Mem0 with Respan.

​
Overview

Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. Respan (formerly Keywords AI) provides complete LLM observability. Combining Mem0 with Respan allows you to:
  1. Add persistent memory to your AI applications
  2. Track interactions across sessions
  3. Monitor memory usage and retrieval with Respan observability
  4. Optimize token usage and reduce costs
You can get your Mem0 API key from the Mem0 dashboard.

​
Setup and Configuration

Install the necessary libraries: 
pip install mem0ai openai
Set up your environment variables: 
import os

# Set your API keys
os.environ["MEM0_API_KEY"] = "your-mem0-api-key"
os.environ["RESPAN_API_KEY"] = "your-respan-api-key"
os.environ["RESPAN_BASE_URL"] = "https://api.respan.ai/api/"

​
Basic Integration Example

Here’s a simple example of using Mem0 with Respan: 
from mem0 import Memory
import os

# Configuration
api_key = os.getenv("MEM0_API_KEY")
respan_api_key = os.getenv("RESPAN_API_KEY")
base_url = os.getenv("RESPAN_BASE_URL") # "https://api.respan.ai/api/"

# Set up Mem0 with Respan as the LLM provider
config = {
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-5-mini",
            "temperature": 0.0,
            "api_key": respan_api_key,
            "openai_base_url": base_url,
        },
    }
}

# Initialize Memory
memory = Memory.from_config(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 Respan with Mem0 through the OpenAI SDK: 
from openai import OpenAI
import os
import json

# Initialize client
client = OpenAI(
    api_key=os.environ.get("RESPAN_API_KEY"),
    base_url=os.environ.get("RESPAN_BASE_URL"),
)

# Sample conversation messages
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."}
]

# Add memory and generate a response
response = client.chat.completions.create(
    model="openai/gpt-4.1-nano",
    messages=messages,
    extra_body={
        "mem0_params": {
            "user_id": "test_user",
            "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 Respan Mem0 integration documentation.

​
Key Features

  1. Memory Integration: Store and retrieve relevant information from past interactions
  2. LLM Observability: Track memory usage and retrieval patterns with Respan
  3. Session Persistence: Maintain context across multiple user sessions
  4. Cost Optimization: Reduce token usage through efficient memory retrieval

​
Conclusion

Integrating Mem0 with Respan 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.

OpenAI Agents SDK

Build monitored agents with OpenAI SDK

AgentOps Integration

Monitor agent performance with AgentOps