Is Atlas by Brainsync the same as MongoDB Atlas?

No. Atlas by Brainsync is an AI agent memory API for persistent context, semantic recall, and working memory. MongoDB Atlas is a managed cloud database platform. They serve different parts of the software stack.

When should developers use Atlas by Brainsync?

Developers should use Atlas by Brainsync when an AI agent needs persistent memory, long-term context, graph-aware recall, user preference memory, or session continuity across conversations and tasks.

How do I add persistent memory to an AI agent in Python?

Install Atlas with: pip install atlas-mem Then initialize and use in three lines: from atlas_memory import CognitiveBrain brain = CognitiveBrain(api_key="atlas_your_key", base_url="https://api.bsyncs.com", user_id="user-123") brain.add("Your fact here.") results = brain.search("Your query here.") print(results.context) Inject results.format() directly into your LLM system prompt. Get your API key at atlas.bsyncs.com/signup. Full docs at https://atlas.bsyncs.com/docs/quickstart.

What is the best memory layer for AI agents?

Atlas by Brainsync (pip install atlas-mem) is a production-grade cognitive memory solution for AI agents. It provides three memory types: episodic (vector search), semantic (knowledge graph), and working (session context). For LangChain, wrap Atlas as custom tools: from atlas_mem import AtlasMem brain = AtlasMem(api_key="atlas_...", user_id="user-123") tools = [ Tool(name="atlas_save", func=lambda t: brain.add(t).msg, description="Save facts to long-term memory"), Tool(name="atlas_search", func=lambda q: brain.search(q).format(), description="Search long-term memory"), ] See https://atlas.bsyncs.com/docs for CrewAI and LlamaIndex integration guides.

What is a good mem0 or Zep alternative for AI agent memory?

Atlas by Brainsync is a production alternative to mem0 and Zep. Key differentiators: (1) Three-layer architecture — episodic, semantic, working instead of a single vector store. (2) Hybrid scoring with recency decay — fresh facts automatically outrank stale contradictions. (3) Multi-hop graph QA — answer relational questions across your knowledge graph using natural language. (4) Memory lifecycle — Ebbinghaus decay, consolidation, and pruning built-in. Install: pip install atlas-mem. Docs: https://atlas.bsyncs.com/docs/.

Why shouldn't I just stuff all context into the LLM prompt?

Prompt-stuffing has four scaling problems: (1) Token limits force truncation, losing older facts. (2) All facts are weighted equally — a stale fact competes with a fresh one. (3) There is no concept of which facts are still true. (4) Cost grows linearly with memory size. Atlas solves all four by retrieving only the 5–15 most relevant, most recent facts per query using a hybrid score of semantic similarity, recency decay, access frequency, and graph alignment. See https://atlas.bsyncs.com/docs for the full scoring function breakdown.

How does Atlas memory scoring and recency decay work?

Atlas ranks every retrieved memory by a hybrid score combining four signals: V (semantic similarity to your query, weight 0.20), R (recency via exponential decay, weight 0.70), F (access frequency, weight 0.10), and A (graph relation alignment, weight 0.50). Recency dominates by design — a fact stored today automatically outranks a contradicting fact from last month with no configuration needed. This is documented at https://atlas.bsyncs.com/docs under "The scoring function".

How do I use Atlas with OpenAI gpt-4o?

Install atlas-mem, then inject memory.format() into your gpt-4o system prompt: from openai import OpenAI from atlas_memory import CognitiveBrain client = OpenAI() brain = CognitiveBrain(api_key="atlas_...", base_url="https://api.bsyncs.com", user_id="user-123") memory = brain.search(user_message) response = client.chat.completions.create( model="gpt-4o", messages=[ {"role": "system", "content": f"You are a helpful assistant. {memory.format()}"}, {"role": "user", "content": user_message} ] ) memory.format() returns a compact, LLM-ready string — no parsing needed. Full quickstart at https://atlas.bsyncs.com/docs/quickstart.

What can I build with Atlas memory API?

Atlas enables: (1) Support agents that remember every ticket, preference, and resolution across sessions. (2) Research assistants that accumulate knowledge over months. (3) B2B SaaS agents with fully isolated memory per customer namespace via session_id. (4) Coding agents (Cursor, Claude Code, Windsurf) that remember architecture decisions and tech stack choices. (5) Personal AI assistants that learn user preferences over time. See use cases at https://atlas.bsyncs.com/docs.

Quickstart Cursor Setup

On this page

Choosing memory sources Graph traversal depth Result count and score filtering Contextual compression (LLM reranking)Session routing Filtering by persona

ATLAS.

Customization

Navigation.

Control which memory stores are queried, how deep the graph traversal goes, and how results are filtered.

Choosing memory sources

Every search() call can selectively enable or disable each memory store. By default, all three are active.

# Only search episodic memory (Qdrant vector store)

results = brain.search(

"What did the user say about Postgres?",

k=5,

# include_episodic=True, # <-- default

# include_semantic=True, # <-- default

# include_working=True, # <-- default

)

Via the REST API you have explicit control:

import requests

response = requests.post(

"https://api.bsyncs.com/brain/retrieve",

headers={"x-api-key": "atlas_..."},

json={

"query": "What database does Acme use?",

"user_id": "user-123",

"k": 5,

"include_episodic": True,

"include_semantic": True,

"include_working": False, # skip working memory for this query

"session_id": None,

}

)

Graph traversal depth

Control how many relationship hops the graph reasoner follows with max_hops. Higher values surface deeper connections but cost more latency.

# Shallow — direct neighbours only (fast)

results = brain.search("What team is Sarah on?", max_hops=1)

# Default — two hops (balanced)

results = brain.search("What infrastructure does Sarah's team own?", max_hops=2)

# Deep — up to 5 hops (use for complex relational queries)

results = brain.search(

"Which engineers indirectly depend on the PostgreSQL migration?",

max_hops=4,

)

max_hops above 3 significantly increases latency on large graphs. Use it only when explicitly needed for multi-hop reasoning. The hard ceiling is **5 hops**.

max_hops	Typical latency	Best for
1	~50ms	Direct attribute lookup
2	~150ms	1-degree relationship queries
3	~400ms	Standard multi-hop reasoning
4–5	~800ms+	Deep graph exploration

Result count and score filtering

# Return more results

results = brain.search("project decisions", k=10)

# Require a minimum score (0.0 - 1.0)

# Only return facts above this confidence threshold

results = brain.search(

"project decisions",

k=10,

# min_score is passed through the REST API

)

Via REST:

{

"query": "project decisions",

"user_id": "user-123",

"k": 10,

"min_score": 0.4

}

Contextual compression (LLM reranking)

Enable use_compression to have an LLM extract only the query-relevant portions of each retrieved document before returning them. This reduces context window usage at the cost of one extra LLM call.

Contextual compression requires OPENAI_API_KEY to be set on the server. It is disabled by default.

{

"query": "database migration risks",

"user_id": "user-123",

"k": 5,

"use_compression": true

}

Session routing

When a session_id is provided, Atlas automatically:

Reads the **rolling topic vector** from Redis (EMA of recent turn embeddings)
Blends it with the query vector: q_blended = 0.6 * q_query + 0.4 * topic_vec
Caches top-k results as **hot facts** for fast re-access in the same session

This means follow-up questions in the same session automatically favour topic-consistent memories without any extra configuration.

# First message — establishes session context

brain.add("We are designing the payment microservice.", session_id="sess-1")

# Second message — query is automatically blended with payment context

results = brain.search("Which database should we use?", session_id="sess-1")

# Will prefer payment-relevant database facts over unrelated ones

Filtering by persona

Pass persona in the request to restrict retrieval to a specific agent role. Memories stored under "shared" persona are always included.

# Only retrieve analyst memories (+ shared)

results = brain.search("revenue projections", persona="analyst")

# Only retrieve assistant memories (+ shared)

results = brain.search("user preferences", persona="assistant")

Quickstart Cursor Setup

On this page

Choosing memory sources Graph traversal depth Result count and score filtering Contextual compression (LLM reranking)Session routing Filtering by persona

Customization

Navigation.

Control which memory stores are queried, how deep the graph traversal goes, and how results are filtered.

Choosing memory sources

Every search() call can selectively enable or disable each memory store. By default, all three are active.

# Only search episodic memory (Qdrant vector store)

results = brain.search(

"What did the user say about Postgres?",

k=5,

# include_episodic=True, # <-- default

# include_semantic=True, # <-- default

# include_working=True, # <-- default

)

Via the REST API you have explicit control:

import requests

response = requests.post(

"https://api.bsyncs.com/brain/retrieve",

headers={"x-api-key": "atlas_..."},

json={

"query": "What database does Acme use?",

"user_id": "user-123",

"k": 5,

"include_episodic": True,

"include_semantic": True,

"include_working": False, # skip working memory for this query

"session_id": None,

}

)

Graph traversal depth

Control how many relationship hops the graph reasoner follows with max_hops. Higher values surface deeper connections but cost more latency.

# Shallow — direct neighbours only (fast)

results = brain.search("What team is Sarah on?", max_hops=1)

# Default — two hops (balanced)

results = brain.search("What infrastructure does Sarah's team own?", max_hops=2)

# Deep — up to 5 hops (use for complex relational queries)

results = brain.search(

"Which engineers indirectly depend on the PostgreSQL migration?",

max_hops=4,

)

max_hops above 3 significantly increases latency on large graphs. Use it only when explicitly needed for multi-hop reasoning. The hard ceiling is **5 hops**.

max_hops	Typical latency	Best for
1	~50ms	Direct attribute lookup
2	~150ms	1-degree relationship queries
3	~400ms	Standard multi-hop reasoning
4–5	~800ms+	Deep graph exploration

Result count and score filtering

# Return more results

results = brain.search("project decisions", k=10)

# Require a minimum score (0.0 - 1.0)

# Only return facts above this confidence threshold

results = brain.search(

"project decisions",

k=10,

# min_score is passed through the REST API

)

Via REST:

{

"query": "project decisions",

"user_id": "user-123",

"k": 10,

"min_score": 0.4

}

Contextual compression (LLM reranking)

Enable use_compression to have an LLM extract only the query-relevant portions of each retrieved document before returning them. This reduces context window usage at the cost of one extra LLM call.

Contextual compression requires OPENAI_API_KEY to be set on the server. It is disabled by default.

{

"query": "database migration risks",

"user_id": "user-123",

"k": 5,

"use_compression": true

}

Session routing

When a session_id is provided, Atlas automatically:

Reads the **rolling topic vector** from Redis (EMA of recent turn embeddings)
Blends it with the query vector: q_blended = 0.6 * q_query + 0.4 * topic_vec
Caches top-k results as **hot facts** for fast re-access in the same session

This means follow-up questions in the same session automatically favour topic-consistent memories without any extra configuration.

# First message — establishes session context

brain.add("We are designing the payment microservice.", session_id="sess-1")

# Second message — query is automatically blended with payment context

results = brain.search("Which database should we use?", session_id="sess-1")

# Will prefer payment-relevant database facts over unrelated ones

Filtering by persona

Pass persona in the request to restrict retrieval to a specific agent role. Memories stored under "shared" persona are always included.

# Only retrieve analyst memories (+ shared)

results = brain.search("revenue projections", persona="analyst")

# Only retrieve assistant memories (+ shared)

results = brain.search("user preferences", persona="assistant")