Can You Give Claude or GPT Long-Term Memory
Memory for Claude
Claude supports memory through two mechanisms. Claude Code and Claude Desktop support the Model Context Protocol (MCP), which lets you connect external tools, including memory servers, through a configuration file. You add the memory server's URL and your API key to the MCP config, restart the client, and Claude gains access to memory tools: store, recall, update, forget, and more.
{
"mcpServers": {
"adaptive-recall": {
"type": "url",
"url": "https://mcp.adaptiverecall.com/mcp",
"headers": {
"Authorization": "Bearer YOUR_API_KEY"
}
}
}
}Once connected, Claude can store observations during conversations, recall relevant context from previous sessions, explore entity relationships in the knowledge graph, and update or remove memories as information changes. The memory persists across all sessions in that configuration, giving Claude continuity it does not have natively.
For Claude via the Anthropic API, you implement memory at the application level. Before each API call, retrieve relevant memories and inject them into the system message. After each conversation, extract noteworthy information and store it. The integration pattern is the same as for any LLM API.
Memory for GPT
ChatGPT includes a basic memory feature for consumer users, but the GPT API does not provide memory. Applications using the OpenAI API need to implement memory externally, the same as with the Anthropic API.
The integration is straightforward: call the memory service to retrieve relevant context before each GPT API call, include that context in the system message, and call the memory service to store extracted information after the conversation. The memory service handles embedding, storage, retrieval, and lifecycle management. Your application code handles the injection and extraction triggers.
# Before each GPT call
memories = recall(query=user_message, user_id=user_id)
system_msg = base_prompt + format_memories(memories)
# GPT API call with memory context
response = openai.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": system_msg},
{"role": "user", "content": user_message}
]
)
# After the conversation, extract and store
store(content=extracted_info, user_id=user_id)Memory for Other Models
The same pattern works for Gemini, Mistral, Llama, and any other model that accepts a system message. Memory is model-agnostic because it operates at the prompt level. The memory system stores and retrieves information independently of which model consumes it. This means you can switch models without losing accumulated memories, and you can even share memories across different models if your application uses multiple providers.
What Changes with Memory
Without memory, every conversation with Claude or GPT starts from zero. The model has no knowledge of your previous interactions, your preferences, your project details, or any context from past sessions. You provide this context manually in every conversation, consuming time and tokens.
With memory, the model receives relevant context automatically. It knows your technology stack, your coding preferences, your project history, and your communication patterns. Responses are more specific, more useful, and more personalized. Conversations are shorter because you do not need to re-explain your situation. And the experience improves over time as the memory store accumulates more knowledge about you and your work.
Adaptive Recall adds cognitive scoring to this foundation, so the memory that gets injected is not just similar to the current query but also recent, frequently useful, connected through entity relationships, and well corroborated. This produces consistently better context injection than simple similarity search.
Give Claude or GPT a memory that learns. Adaptive Recall connects in minutes through MCP or REST API.
Get Started Free