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.

Claude Code Setup Introduction

On this page

Prerequisites Step 1 — Install the SDK Step 2 — Create the memory tool script Step 3 — Configure environment variables Step 4 — Create an ANTIGRAVITY.md file Step 5 — Test the integration Step 6 — Test memory storage Step 7 — Test memory recall Step 8 — Test memory reasoning Step 9 — Antigravity Agent Workflow Advanced: Auto-store on task completion Verify Everything Works

ATLAS.

AI tools

Antigravity Setup.

Give Antigravity persistent memory across sessions using Atlas — remember codebases, architecture decisions, conventions, and workflow context automatically.

Antigravity is an AI agent platform for development workflows. Atlas supercharges it with persistent long-term memory so that Antigravity remembers your project structure, coding standards, past fixes, dependencies, and team conventions across every session.

Prerequisites

Antigravity installed
Atlas API key from atlas.bsyncs.com
Python 3.9+
Existing project directory

Step 1 — Install the SDK

pip install atlas-mem

Verify installation:

pip show atlas-mem

Step 2 — Create the memory tool script

Create atlas_memory.py inside your project root.

Example:

/your/project/path/atlas_memory.py

Add:

#!/usr/bin/env python3

"""

Atlas memory tool for Antigravity.

Called by Antigravity agents through workflow instructions.

"""

import sys

import os

import json

from atlas_mem import AtlasMem

brain = AtlasMem(

api_key=os.environ["ATLAS_API_KEY"],

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

user_id=os.environ.get("ATLAS_USER_ID", "antigravity-user"),

persona=os.environ.get("ATLAS_PERSONA", "shared"),

)

def cmd_store(text: str) -> None:

result = brain.add(text, source="user")

print(json.dumps({

"status": "stored",

"entities": result.entities_extracted,

"relations": result.triples_extracted,

"chunks": result.episodic_chunks,

}))

def cmd_recall(query: str, k: int = 5) -> None:

results = brain.search(query, k=k)

output = {

"context": results.context,

"facts": [

{

"fact": f["fact"],

"score": round(f["score"], 3),

"source": f.get("source_type"),

}

for f in results.facts

}

print(json.dumps(output, indent=2))

def cmd_ask(question: str) -> None:

answer = brain.ask(question, max_hops=3)

print(json.dumps({"answer": answer}))

def cmd_stats() -> None:

print(json.dumps(brain.stats()))

commands = {

"store": cmd_store,

"recall": cmd_recall,

"ask": cmd_ask,

"stats": cmd_stats,

}

if __name__ == "__main__":

if len(sys.argv) < 2:

print(json.dumps({

"error": "Usage: atlas_memory.py "

}))

sys.exit(1)

command = sys.argv[1]

text = " ".join(sys.argv[2:])

if command not in commands:

print(json.dumps({

"error": f"Unknown command: {command}"

}))

sys.exit(1)

if command == "stats":

commands[command]()

else:

commands[command](text)

Step 3 — Configure environment variables

This setup intentionally avoids .env files for security reasons.

Load credentials directly into the active PowerShell session. Run:

$env:ATLAS_API_KEY="atlas_your_key_here"

$env:ATLAS_USER_ID="your-name"

$env:ATLAS_PERSONA="antigravity-agent"

Verify:

echo $env:ATLAS_API_KEY

echo $env:ATLAS_USER_ID

echo $env:ATLAS_PERSONA

Step 4 — Create an ANTIGRAVITY.md file

ANTIGRAVITY.md is the instruction file Antigravity reads during workflows and agent execution. Create one in your project root.

Example:

/your/project/path/ANTIGRAVITY.md

Add:

# Project Memory — Antigravity Instructions

## Atlas Memory System

You have access to a persistent memory tool via Python:

`python atlas_memory.py `

### Commands

- `store ""` — Save an important fact, decision, or discovery

- `recall ""` — Retrieve relevant memories before answering

- `ask ""` — Answer a complex question using graph reasoning

- `stats` — Check memory system status

---

## When to use memory

### ALWAYS recall before:

- answering architecture questions

- modifying existing modules

- suggesting libraries/tools

- implementing backend features

- changing conventions

### ALWAYS store after:

- successful implementations

- bug fixes

- discovering hidden constraints

- architectural decisions

- establishing conventions

---

## Example usage

```powershell

python atlas_memory.py store "This project uses Next.js and TailwindCSS"

python atlas_memory.py recall "frontend technologies"

python atlas_memory.py ask "What technologies does this project use?"

```

---

## Project Conventions

Antigravity will expand this section as the project evolves.

Step 5 — Test the integration

Open PowerShell in your project directory:

cd "/your/project/path"

Load environment variables:

$env:ATLAS_API_KEY="atlas_your_key_here"

$env:ATLAS_USER_ID="your-name"

$env:ATLAS_PERSONA="antigravity-agent"

Step 6 — Test memory storage

Store memory:

python atlas_memory.py store "This project uses Next.js and TailwindCSS"

Expected:

{

"status": "stored"

}

Step 7 — Test memory recall

python atlas_memory.py recall "frontend technologies"

Expected:

{

"context": "...",

"facts": [...]

}

Step 8 — Test memory reasoning

python atlas_memory.py ask "What technologies does this project use?"

Note: If ask fails with an HTTP/API error, Atlas backend reasoning services may be temporarily unavailable. Stored memories remain accessible through recall.

Step 9 — Antigravity Agent Workflow

Before answering

Agents should first retrieve context:

python atlas_memory.py recall ""

Example:

python atlas_memory.py recall "authentication architecture"

After task completion

Agents should store learnings:

python atlas_memory.py store "

Example:

python atlas_memory.py store "Implemented JWT authentication middleware using Express.js"

Advanced: Auto-store on task completion

Add this to ANTIGRAVITY.md:

## End of session

Before finishing:

1. `python atlas_memory.py store "

2. `python atlas_memory.py store ""`

Verify Everything Works

Run:

python atlas_memory.py stats

Expected:

{

"episodic_count": 5,

"semantic_entities": 12,

"semantic_relations": 7

}

A healthy project memory graph grows over time as Antigravity learns the codebase and workflows.

Claude Code Setup Introduction

On this page

AI tools

Antigravity Setup.

Give Antigravity persistent memory across sessions using Atlas — remember codebases, architecture decisions, conventions, and workflow context automatically.

Prerequisites

Antigravity installed
Atlas API key from atlas.bsyncs.com
Python 3.9+
Existing project directory

Step 1 — Install the SDK

pip install atlas-mem

Verify installation:

pip show atlas-mem

Step 2 — Create the memory tool script

Create atlas_memory.py inside your project root.

Example:

/your/project/path/atlas_memory.py

Add:

#!/usr/bin/env python3

"""

Atlas memory tool for Antigravity.

Called by Antigravity agents through workflow instructions.

"""

import sys

import os

import json

from atlas_mem import AtlasMem

brain = AtlasMem(

api_key=os.environ["ATLAS_API_KEY"],

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

user_id=os.environ.get("ATLAS_USER_ID", "antigravity-user"),

persona=os.environ.get("ATLAS_PERSONA", "shared"),

)

def cmd_store(text: str) -> None:

result = brain.add(text, source="user")

print(json.dumps({

"status": "stored",

"entities": result.entities_extracted,

"relations": result.triples_extracted,

"chunks": result.episodic_chunks,

}))

def cmd_recall(query: str, k: int = 5) -> None:

results = brain.search(query, k=k)

output = {

"context": results.context,

"facts": [

{

"fact": f["fact"],

"score": round(f["score"], 3),

"source": f.get("source_type"),

}

for f in results.facts

}

print(json.dumps(output, indent=2))

def cmd_ask(question: str) -> None:

answer = brain.ask(question, max_hops=3)

print(json.dumps({"answer": answer}))

def cmd_stats() -> None:

print(json.dumps(brain.stats()))

commands = {

"store": cmd_store,

"recall": cmd_recall,

"ask": cmd_ask,

"stats": cmd_stats,

}

if __name__ == "__main__":

if len(sys.argv) < 2:

print(json.dumps({

"error": "Usage: atlas_memory.py "

}))

sys.exit(1)

command = sys.argv[1]

text = " ".join(sys.argv[2:])

if command not in commands:

print(json.dumps({

"error": f"Unknown command: {command}"

}))

sys.exit(1)

if command == "stats":

commands[command]()

else:

commands[command](text)

Step 3 — Configure environment variables

This setup intentionally avoids .env files for security reasons.

Load credentials directly into the active PowerShell session. Run:

$env:ATLAS_API_KEY="atlas_your_key_here"

$env:ATLAS_USER_ID="your-name"

$env:ATLAS_PERSONA="antigravity-agent"

Verify:

echo $env:ATLAS_API_KEY

echo $env:ATLAS_USER_ID

echo $env:ATLAS_PERSONA

Step 4 — Create an ANTIGRAVITY.md file

ANTIGRAVITY.md is the instruction file Antigravity reads during workflows and agent execution. Create one in your project root.

Example:

/your/project/path/ANTIGRAVITY.md

Add:

# Project Memory — Antigravity Instructions

## Atlas Memory System

You have access to a persistent memory tool via Python:

`python atlas_memory.py `

### Commands

- `store ""` — Save an important fact, decision, or discovery

- `recall ""` — Retrieve relevant memories before answering

- `ask ""` — Answer a complex question using graph reasoning

- `stats` — Check memory system status

---

## When to use memory

### ALWAYS recall before:

- answering architecture questions

- modifying existing modules

- suggesting libraries/tools

- implementing backend features

- changing conventions

### ALWAYS store after:

- successful implementations

- bug fixes

- discovering hidden constraints

- architectural decisions

- establishing conventions

---

## Example usage

```powershell

python atlas_memory.py store "This project uses Next.js and TailwindCSS"

python atlas_memory.py recall "frontend technologies"

python atlas_memory.py ask "What technologies does this project use?"

```

---

## Project Conventions

Antigravity will expand this section as the project evolves.

Step 5 — Test the integration

Open PowerShell in your project directory:

cd "/your/project/path"

Load environment variables:

$env:ATLAS_API_KEY="atlas_your_key_here"

$env:ATLAS_USER_ID="your-name"

$env:ATLAS_PERSONA="antigravity-agent"

Step 6 — Test memory storage

Store memory:

python atlas_memory.py store "This project uses Next.js and TailwindCSS"

Expected:

{

"status": "stored"

}

Step 7 — Test memory recall

python atlas_memory.py recall "frontend technologies"

Expected:

{

"context": "...",

"facts": [...]

}

Step 8 — Test memory reasoning

python atlas_memory.py ask "What technologies does this project use?"

Note: If ask fails with an HTTP/API error, Atlas backend reasoning services may be temporarily unavailable. Stored memories remain accessible through recall.

Step 9 — Antigravity Agent Workflow

Before answering

Agents should first retrieve context:

python atlas_memory.py recall ""

Example:

python atlas_memory.py recall "authentication architecture"

After task completion

Agents should store learnings:

python atlas_memory.py store "

Example:

python atlas_memory.py store "Implemented JWT authentication middleware using Express.js"

Advanced: Auto-store on task completion

Add this to ANTIGRAVITY.md:

## End of session

Before finishing:

1. `python atlas_memory.py store "

2. `python atlas_memory.py store ""`

Verify Everything Works

Run:

python atlas_memory.py stats

Expected:

{

"episodic_count": 5,

"semantic_entities": 12,

"semantic_relations": 7

}

A healthy project memory graph grows over time as Antigravity learns the codebase and workflows.