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.

Introduction Navigation

On this page

1. Install the SDK 2. Get your API key 3. Your first memory operations 4. Add memory to an OpenAI call 5. Async usage (FastAPI / LangGraph)6. Verify the service is running What's next?

ATLAS.

Getting started

Quickstart.

Add long-term memory to your AI agent in under 5 minutes.

1. Install the SDK

pip install atlas-mem

2. Get your API key

Store your API key in an environment variable — never hardcode it in source files.

.env

export ATLAS_API_KEY="atlas_your_key_here"

3. Your first memory operations

import os

from atlas_mem import AtlasMem

brain = AtlasMem(

api_key=os.environ["ATLAS_API_KEY"],

base_url="https://api.bsyncs.com",

user_id="user-123",

session_id="session-abc",

)

# Store a fact

brain.add("Sarah Jenkins is the Lead Software Engineer at Acme Corp.")

brain.add("Acme Corp recently migrated their primary database to PostgreSQL.")

brain.add("Sarah prefers async Python and has 8 years of backend experience.")

# Search for relevant context

results = brain.search("Who manages engineering at Acme?")

# Inject into your LLM system prompt

print(results.format())

Expected output:

Software Engineer at Acme Corp.  (high confidence, via episodic)
e_corp  (high confidence, via semantic)
and has 8 years of backend experience.  (medium confidence, via episodic)

4. Add memory to an OpenAI call

Here is the pattern used in production — retrieve context, inject into the system prompt, then call the LLM.

import os

from openai import OpenAI

from atlas_mem import AtlasMem

openai_client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

brain = AtlasMem(

api_key=os.environ["ATLAS_API_KEY"],

base_url="https://api.bsyncs.com",

user_id="user-123",

session_id="session-abc",

)

def chat(user_message: str) -> str:

# 1. Retrieve relevant memory

memory = brain.search(user_message, k=5)

memory_context = memory.format()

# 2. Build system prompt with memory

system_prompt = f"""You are a helpful assistant with long-term memory.

MEMORY CONTEXT (use this to personalise your response):

{memory_context}

Always reference specific facts from memory when relevant."""

# 3. Call the LLM

response = openai_client.chat.completions.create(

model="gpt-4o",

messages=[

{"role": "system", "content": system_prompt},

{"role": "user", "content": user_message},

]

)

assistant_reply = response.choices[0].message.content

# 4. Store both turns in memory

brain.add(user_message, source="user")

brain.add(assistant_reply, source="assistant")

return assistant_reply

# Example usage

print(chat("What database does Acme Corp use?"))

5. Async usage (FastAPI / LangGraph)

import asyncio

import os

from atlas_mem import AsyncAtlasMem

async def main():

async with AsyncAtlasMem(

api_key=os.environ["ATLAS_API_KEY"],

base_url="https://api.bsyncs.com",

user_id="user-123",

session_id="session-abc",

) as brain:

# Batch ingest historical context

await brain.add_batch([

"The project uses a microservices architecture.",

"Services communicate via gRPC internally.",

"The team follows trunk-based development.",

])

# Retrieve with graph traversal

results = await brain.search(

"How are services connected?",

k=5,

max_hops=2, # traverse up to 2 hops in the knowledge graph

)

for fact in results:

print(f"[{fact['source_type']}] {fact['fact']} (score: {fact['score']:.2f})")

asyncio.run(main())

6. Verify the service is running

health = brain.health()

print(health)

# {

# "ready": true,

# "models_loaded": true,

# "neo4j": "connected",

# "redis": "connected",

# "qdrant": "connected",

# "version": "1.0.0"

# }

Next steps

Global Settings

Configure scoring weights, memory decay, and pruning thresholds.

Ingest endpoint

Detailed schema for ingesting text, including LLM extraction options.

Graph QA

Query your knowledge graph in natural language.

AI Tool Setup

Wire Atlas into Cursor, Claude Code, or Windsurf.

Introduction Navigation

On this page

1. Install the SDK 2. Get your API key 3. Your first memory operations 4. Add memory to an OpenAI call 5. Async usage (FastAPI / LangGraph)6. Verify the service is running What's next?

Getting started

Quickstart.

Add long-term memory to your AI agent in under 5 minutes.

1. Install the SDK

pip install atlas-mem

2. Get your API key

Store your API key in an environment variable — never hardcode it in source files.

.env

export ATLAS_API_KEY="atlas_your_key_here"

3. Your first memory operations

import os

from atlas_mem import AtlasMem

brain = AtlasMem(

api_key=os.environ["ATLAS_API_KEY"],

base_url="https://api.bsyncs.com",

user_id="user-123",

session_id="session-abc",

)

# Store a fact

brain.add("Sarah Jenkins is the Lead Software Engineer at Acme Corp.")

brain.add("Acme Corp recently migrated their primary database to PostgreSQL.")

brain.add("Sarah prefers async Python and has 8 years of backend experience.")

# Search for relevant context

results = brain.search("Who manages engineering at Acme?")

# Inject into your LLM system prompt

print(results.format())

Expected output:

Software Engineer at Acme Corp.  (high confidence, via episodic)
e_corp  (high confidence, via semantic)
and has 8 years of backend experience.  (medium confidence, via episodic)

4. Add memory to an OpenAI call

Here is the pattern used in production — retrieve context, inject into the system prompt, then call the LLM.

import os

from openai import OpenAI

from atlas_mem import AtlasMem

openai_client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

brain = AtlasMem(

api_key=os.environ["ATLAS_API_KEY"],

base_url="https://api.bsyncs.com",

user_id="user-123",

session_id="session-abc",

)

def chat(user_message: str) -> str:

# 1. Retrieve relevant memory

memory = brain.search(user_message, k=5)

memory_context = memory.format()

# 2. Build system prompt with memory

system_prompt = f"""You are a helpful assistant with long-term memory.

MEMORY CONTEXT (use this to personalise your response):

{memory_context}

Always reference specific facts from memory when relevant."""

# 3. Call the LLM

response = openai_client.chat.completions.create(

model="gpt-4o",

messages=[

{"role": "system", "content": system_prompt},

{"role": "user", "content": user_message},

]

)

assistant_reply = response.choices[0].message.content

# 4. Store both turns in memory

brain.add(user_message, source="user")

brain.add(assistant_reply, source="assistant")

return assistant_reply

# Example usage

print(chat("What database does Acme Corp use?"))

5. Async usage (FastAPI / LangGraph)

import asyncio

import os

from atlas_mem import AsyncAtlasMem

async def main():

async with AsyncAtlasMem(

api_key=os.environ["ATLAS_API_KEY"],

base_url="https://api.bsyncs.com",

user_id="user-123",

session_id="session-abc",

) as brain:

# Batch ingest historical context

await brain.add_batch([

"The project uses a microservices architecture.",

"Services communicate via gRPC internally.",

"The team follows trunk-based development.",

])

# Retrieve with graph traversal

results = await brain.search(

"How are services connected?",

k=5,

max_hops=2, # traverse up to 2 hops in the knowledge graph

)

for fact in results:

print(f"[{fact['source_type']}] {fact['fact']} (score: {fact['score']:.2f})")

asyncio.run(main())

6. Verify the service is running

health = brain.health()

print(health)

# {

# "ready": true,

# "models_loaded": true,

# "neo4j": "connected",

# "redis": "connected",

# "qdrant": "connected",

# "version": "1.0.0"

# }

Next steps

Global Settings

Configure scoring weights, memory decay, and pruning thresholds.

Ingest endpoint

Detailed schema for ingesting text, including LLM extraction options.

Graph QA

Query your knowledge graph in natural language.

AI Tool Setup

Wire Atlas into Cursor, Claude Code, or Windsurf.