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.

Navigation Claude Code Setup

On this page

Prerequisites Step 1 — Install the SDK Step 2 — Create the memory helper script Step 3 — Set environment variables Step 4 — Create a Cursor Rule Step 5 — Test it Tips for Cursor + Atlas

ATLAS.

AI tools

Cursor Setup.

Give Cursor persistent memory across coding sessions using the Atlas SDK.

Cursor is an AI-first code editor. By wiring Atlas into it, you can have Cursor remember architectural decisions, project conventions, past bugs, and team preferences across sessions — even across different projects.

Prerequisites

Cursor installed and configured
Atlas API key from atlas.bsyncs.com
Python 3.9+

Step 1 — Install the SDK

pip install atlas-mem

Step 2 — Create the memory helper script

Create a file called atlas_memory.py in your project root. Cursor's AI features can call this directly.

# atlas_memory.py

"""

Atlas memory helper for Cursor sessions.

Usage:

python atlas_memory.py add "We decided to use Postgres over MySQL for ACID compliance"

python atlas_memory.py search "database choice"

python atlas_memory.py ask "Why did we choose Postgres?"

"""

import sys

import os

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", "cursor-dev"),

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

session_id=os.environ.get("ATLAS_SESSION_ID"),

)

def main():

if len(sys.argv) < 3:

print("Usage: python atlas_memory.py [add|search|ask] ")

sys.exit(1)

command = sys.argv[1]

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

if command == "add":

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

print(f"Stored: {result.entities_extracted} entities, {result.triples_extracted} relations")

elif command == "search":

results = brain.search(text, k=5)

print(results.format())

elif command == "ask":

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

print(answer)

else:

print(f"Unknown command: {command}")

if __name__ == "__main__":

main()

Step 3 — Set environment variables

Add these to your shell profile (~/.zshrc or ~/.bashrc) or a .env file in your project:

export ATLAS_API_KEY="atlas_your_key_here"

export ATLAS_USER_ID="your-name" # your personal namespace

export ATLAS_SESSION_ID="cursor-session" # optional working memory

Add .env to your .gitignore. Never commit API keys.

Step 4 — Create a Cursor Rule

Go to Cursor Settings → Rules for AI and add the following rule. This teaches Cursor to consult Atlas before and after each significant response.

You have access to a long-term memory system called Atlas.

BEFORE answering architectural, technical, or project-specific questions, run:

python atlas_memory.py search "

and include the retrieved context in your response.

AFTER making an important architectural decision, design choice, or discovering a non-obvious bug, run:

python atlas_memory.py add ""

Facts worth storing:

- Technology choices and their rationale ("We use gRPC over REST for internal service communication")

- Non-obvious bug fixes ("The race condition in payment_service.py was caused by...")

- Team conventions ("All API responses use snake_case, never camelCase")

- Performance findings ("Redis pipeline batching reduced latency by 40% for bulk writes")

- Dependency notes ("Do not upgrade langchain-core above 0.2.40 — breaks graph traversal")

Step 5 — Test it

In Cursor's terminal:

# Store your first architectural decision

python atlas_memory.py add "We use PostgreSQL as the primary database. Chose it over MySQL for its robust JSONB support."

# Ask a question

python atlas_memory.py ask "Why do we use PostgreSQL?"

Now open Cursor's chat and ask: "What database are we using and why?" — Cursor will retrieve and surface the answer from Atlas.

Tips for Cursor + Atlas

Store decisions immediately

The best habit is to store a fact right after Cursor makes a recommendation you accept. Say: "Store this decision in Atlas" and Cursor will run `atlas_memory.py add` for you.

Use project-specific personas

Set `ATLAS_PERSONA=<project-name>` so memories from different projects stay separated, even under the same user namespace.

Search before asking

Before asking Cursor a question about an existing system, prompt it with: "Search Atlas for context on X, then answer." This ensures it uses your stored knowledge before hallucinating.