Give Your AI Agents a Memory

The problem

Your AI starts fresh
every single time.

Every conversation, your agent wakes up with zero memory. You have been talking to it for months — but it still does not know who you are.

🍋

Every chat session, your agent forgets everything. Projects, decisions, context, team members — gone. Blank slate, every single time.

🔁

You repeat yourself constantly. Who you are, what you are building, who is involved. You have typed "I am working on a startup called..." more times than you can count.

😲

Your agents cannot share what they have learned. Your coding agent does not know what your research agent discovered. Knowledge stays trapped in individual sessions.

🗂

The knowledge lives in chat logs no one reads. Buried in scrollback, impossible to search, impossible to connect. Effectively lost.

The difference

What if your agent
could remember?

Here is what the first message of a session looks like — with and without DejaView.

Without DejaView

🤖 AI Agent "Hi! I'm your AI assistant. How can I help you today?"

Blank slate. Every time.

Your agent has no idea who you are, what you are building, or what you decided last week. You are starting from zero. Again.

With DejaView

🤖 AI Agent "Hey! Loaded your context. Picking up on Project Phoenix — last session you decided to use microservices for scaling. You are meeting Jordan (potential partner from the conference) on Thursday. Want to continue where we left off?"

Picks up where you left off.

Agent loads your graph on startup. Knows your projects, your team, your decisions, your preferences. Zero re-explaining.

How it works

Your knowledge graph
builds itself.

You just talk to your agent. Behind the scenes, your graph grows automatically — and any agent can tap into it instantly.

You talk normally

No special commands. No forms to fill. Just have a conversation with your agent like you always do.

"Let's work on Project Phoenix. Sam is leading it, we're going with FastAPI."

Your agent writes to DejaView

As your agent learns things, it writes them to your graph automatically. Typed, structured, permanently connected.

Alex -[joined]-> TechCorp as CTO Decided -[use]-> FastAPI for speed Jordan -[met_at]-> Conference

Any agent loads it instantly

Next session — or a brand new specialized agent — loads your full context in one API call. No re-explaining.

GET /v1/entities/Alex -> CTO at TechCorp -> Working on: Project Phoenix -> Partner: Jordan

You explore it too

Browse, search, and visualize your graph yourself. Rediscover decisions, trace connections, find context you forgot you had.

> Who is connected to TechCorp? -> Alex (CTO), Jordan (partner) -> Project Phoenix, RivalCo

Chat logs (flat list) vs knowledge graph (connected nodes)

Chat logs vs knowledge graph — same information, completely different power. Connections reveal what flat lists never could.

Built for the agentic future

An API your agents
can actually use.

DejaView is designed from the ground up to be the memory layer for agentic systems — not just a notes app with an API bolted on.

🔗

Any agent can read and write Simple REST API. Bearer token auth. Works with any AI framework — LangChain, AutoGPT, custom agents, you name it.

🔄

Typed relationships Not just "related to" — but DECIDED, KNOWS, WORKS_AT, DEPENDS_ON. Real semantic meaning agents can reason about.

🔒

Multi-tenant & private Each user has their own isolated graph. Your agents' knowledge never bleeds into anyone else's.

💬

Query in natural language Ask your graph anything. "Who do I know at TechCorp?" "What decisions have we made about Project Phoenix?"

🌐

Built-in graph explorer Visualize your knowledge graph interactively. See how everything connects at a glance.

DejaView knowledge graph explorer showing connected entities

The DejaView graph explorer — your world, fully connected.

Use cases

Your agents, finally
working with you.

What changes when your agents actually remember things.

🤖

Your coding agent remembers your architecture decisions so it stops suggesting patterns you have already rejected.

🧠

Your research agent builds a knowledge map across every paper it reads — connecting authors, concepts, and citations automatically.

💼

Your business agent tracks every contact, company, and opportunity without you having to manage a CRM.

🔗

Spin up a new specialized agent and it instantly knows your full context — goals, decisions, team, history. Zero onboarding.

👤

You search your own graph to rediscover decisions, connections, and insights from months ago — instantly surfaced.

⚡

Share context between agents — your writing agent knows what your research agent learned. They build on each other.

For developers

Two API calls.
That's it.

Integrate DejaView into any agent in minutes. Write what you learn. Read it next time.

agent-memory.sh

# Your agent learns something -- writes it to DejaView
curl -X POST https://api.dejaview.io/v1/facts \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "facts": [
      {"subject": "Alex",     "predicate": "decided",       "object": "use microservices for scaling"},
      {"subject": "TechCorp", "predicate": "competes_with", "object": "RivalCo"},
      {"subject": "Jordan",   "predicate": "introduced_by", "object": "Alex"}
    ]
  }'

# Next agent session -- loads full context instantly
curl https://api.dejaview.io/v1/entities/Alex \
  -H "Authorization: Bearer YOUR_KEY"

# Response: everything your agents ever learned about Alex
# {
#   "entity": "Alex",
#   "facts": [
#     {"predicate": "decided",    "object": "use microservices for scaling"},
#     {"predicate": "joined",     "object": "TechCorp as CTO"},
#     {"predicate": "introduced", "object": "Jordan"},
#     ...
#   ]
# }

Integrations

Plug in anywhere.

Native MCP support, Python SDK, REST API, and tool schemas your agents can load directly. Works with Claude, GPT, Cursor, Windsurf, and any agent framework.

# 1. Install
pip install mcp httpx

# 2. Download the MCP server
curl -O https://raw.githubusercontent.com/JakeC77/DejaView/main/mcp_server.py

# 3. Add to ~/.config/claude/claude_desktop_config.json
{
  "mcpServers": {
    "dejaview": {
      "command": "python3",
      "args": ["/path/to/mcp_server.py"],
      "env": { "DEJAVIEW_API_KEY": "dv_your_key_here" }
    }
  }
}

Claude will automatically call agent_context() at session start, remember() when it learns something, and recall() when it needs context.

import httpx

DV_KEY = "dv_your_key_here"
DV_URL = "https://api.dejaview.io"
headers = {"Authorization": f"Bearer {DV_KEY}"}

# Bootstrap at session start
ctx = httpx.get(f"{DV_URL}/v1/agent-context", headers=headers).json()["context"]

# Remember a fact
httpx.post(f"{DV_URL}/v1/facts", headers=headers, json={
  "facts": [{"subject": "Alice", "predicate": "works_at", "object": "Orbit Labs"}]
})

# Recall an entity
entity = httpx.get(f"{DV_URL}/v1/entities/Alice", headers=headers).json()

# Store facts
curl -X POST https://api.dejaview.io/v1/facts \
  -H "Authorization: Bearer dv_your_key" \
  -H "Content-Type: application/json" \
  -d '{"facts":[{"subject":"Alice","predicate":"works_at","object":"Orbit Labs"}]}'

# Recall an entity
curl https://api.dejaview.io/v1/entities/Alice \
  -H "Authorization: Bearer dv_your_key"

# Session context block
curl https://api.dejaview.io/v1/agent-context \
  -H "Authorization: Bearer dv_your_key"

Full API docs at api.dejaview.io/docs

# Load the tool schema into any agent framework
import httpx, json

schema = httpx.get("https://dejaview.io/tools.json").json()

# Use with LangChain, AutoGen, or any OpenAI function-calling framework
tools = schema["tools"]  # list of OpenAI-compatible tool definitions

Machine-readable schema at dejaview.io/tools.json — load it directly into your agent framework.

🤖 Claude Desktop

⚡ Cursor

🌊 Windsurf

🐍 LangChain

🔧 AutoGen

🦙 Any OpenAI-compatible agent

Interactive Demo

See the graph think.

Hover over nodes. Watch connections light up. This is how your knowledge looks when it's alive.

Search by connection,
not just keywords.

Ask DejaView a question and get a connected subgraph — not a list of documents.

> What do I know about Project Atlas?

Found 23 connections across 4 people, 7 decisions, 3 meetings, and 9 documents — spanning 6 weeks of context.

Pricing

Start free. Scale when ready.

Open source at the core. Pay only when you want hosted convenience or API access.

Free

For individuals who want control

$0 / forever

Open source core
Local graph database
CLI + API
Unlimited nodes & edges
Community support

Clone the Repo

Pro

For knowledge workers who want it all

$12 / month

Hosted graph — zero setup
Web UI + graph explorer
Browser extension
Obsidian & Notion sync
API access
Priority support

Get Started — $12/mo

API

For developers building with memory

$0.01 / query

1,000 free queries/month
Python & TypeScript SDKs
Multi-tenant support
Webhook integrations
99.9% uptime SLA

View on GitHub

Give your AI agents a memory
they can build together

Your AI starts fresh
every single time.

What if your agent
could remember?

Blank slate. Every time.

Picks up where you left off.

Your knowledge graph
builds itself.

You talk normally

Your agent writes to DejaView

Any agent loads it instantly

You explore it too

An API your agents
can actually use.

Your agents, finally
working with you.

Two API calls.
That's it.

Plug in anywhere.

See the graph think.

Search by connection,
not just keywords.

Start free. Scale when ready.

Free

Pro

API

Start building your
agent's memory

Give your AI agents a memorythey can build together

Your AI starts freshevery single time.

What if your agentcould remember?

Blank slate. Every time.

Picks up where you left off.

Your knowledge graphbuilds itself.

You talk normally

Your agent writes to DejaView

Any agent loads it instantly

You explore it too

An API your agentscan actually use.

Your agents, finallyworking with you.

Two API calls.That's it.

Plug in anywhere.

See the graph think.

Search by connection,not just keywords.

Start free. Scale when ready.

Free

Pro

API

Start building youragent's memory

Give your AI agents a memory
they can build together

Your AI starts fresh
every single time.

What if your agent
could remember?

Your knowledge graph
builds itself.

An API your agents
can actually use.

Your agents, finally
working with you.

Two API calls.
That's it.

Search by connection,
not just keywords.

Start building your
agent's memory