Time explaining context to AI
0 % ~47 min/week per developer
The Re-explanation Tax
Every new AI session demands the same explanation. Your stack. Your patterns. Your conventions. Multiplied across five tools, ten sessions, every single day.
Open source · Local first · Model agnostic
Your AI tools have
no memory.
Dot fixes that. One local daemon that gives every AI tool a memory of your codebase. Works with Claude, Copilot, Cursor, and any model API.
Works with Claude Code, GitHub Copilot, Cursor, and more
ai-session re-explained: 2
The problem
You’re the context manager.
You shouldn’t have to be.
Tool Amnesia
Every AI tool lives in its own silo. What Claude learned this morning means nothing to Copilot this afternoon. You’re the only memory connecting them.
a1b2c3 · refactor checkout
d4e5f6 · event sourcing
Why did we choose this approach? I don’t have that context.
The Lost Decision
Your codebase shows what was built. It never shows why. Every architectural decision, every rejected approach, every hard-won lesson — gone the moment the chat closes.
The product
One daemon.
Every tool remembers.
codebase
history
decisions
memories
dot
Claude
Copilot
Cursor
1
Learns your codebase
AST-aware indexing of every file.
2
Captures your decisions
Mined from git, comments, chats.
3
Assembles context
Ranked + delivered in under 100ms.
Dot learns your codebase
Run one command. Dot parses every file with Tree-sitter, chunks it by function and class, and embeds it locally — building a complete map of your project.
~/my-project
$ dot init
✓ index complete · dependency graph built
3,847 files 12,439 chunks graph: 2,103 nodes
Dot captures your decisions
As it reads your git history, Dot surfaces the architectural decisions buried in commit messages — structured, dated, and queryable forever.
git log
abc123
Switched to event sourcing
CRUD caused race conditions at scale
def456
Chose Redis over Memcached
TTL requirements + existing team knowledge
ghi789
Removed sync HTTP calls
Caused cascade timeouts under load
Context assembled in 67ms
Open a file and Dot fires five parallel queries, ranks the results, and hands a perfectly-sized context payload to whichever AI tool you’re using — before you finish typing.
GET localhost:7337/context
✓ context ready · 3,240 tokens · 12 chunks · 2 decisions · 67ms
ai: applying your auth rate-limit pattern to payments,
with the tighter SLA threshold you set last week.
Architecture
Built different.
Not just another RAG wrapper.
[AST chunking]
Structure, not token windows
Naive chunkers slice code every N tokens and shred functions in half. Tree-sitter parses real syntax — each chunk is a whole function, class, or module.
[Local embeddings]
all-MiniLM-L6-v2, on your CPU
Embeddings are generated locally. No API calls, no tokens billed, no code uploaded. Your most sensitive asset never touches a network.
[Sub-100ms]
Pre-indexed and instant
Vectors and the dependency graph are built ahead of time, so every context lookup is a fast in-memory query — real-time on every file switch.
Integrations
Works with every tool
you already use.
Claude Code
MCP ServerNative tool calls. Zero config. dot init and done.
AvailableGitHub Copilot
VS Code APIContext injected automatically on every file switch.
AvailableCursor
REST APIRules injection plus real-time context endpoint.
AvailableNeovim
Lua pluginFor the terminal purists. Full feature parity.
AvailableOllama
Direct100% offline. No APIs. No data ever leaves.
Coming soonJetBrains
PluginIntelliJ, PyCharm, WebStorm, GoLand.
Coming soonContinue.dev
REST APIOpen source IDE extension gets full memory.
Coming soonZed
ExtensionThe fast editor gets a long memory.
Coming soon universal-api
# The universal integration — any tool, one endpoint
GET localhost:7337/context
?file=src/payments/processor.py
?query=add retry logic with exponential backoff
?tokens=4000
# Response in <100ms:
{
"context": "...",
"chunks": 12,
"decisions": 2,
"tokens": 3240,
"assembled_in_ms": 67
}
Get started
Up in two minutes.
Remembering forever.
install — dot
$ pip install dot-ai
Downloading dot-ai-0.1.0...
Installing dependencies...
✓ dot-ai 0.1.0 installed
$ cd my-project && dot init
Scanning project structure...
Parsing with Tree-sitter... ████████████ 100%
Generating embeddings... ████████████ 100%
Building dependency graph... ████████████ 100%
Analyzing git history... ████████████ 100%
✓ 3,847 files indexed
✓ 12,439 semantic chunks
✓ 2,103 dependency nodes
✓ 23 decisions captured from git history
✓ MCP server registered with Claude Code
✓ VS Code extension activated
● dot is running. Your AI tools now have memory.
$ dot status
● daemon running (pid 8432, uptime 1m)
project my-project
files 3,847
memories 23
last sync just now
api http://localhost:7337
integrations claude-code ✓ copilot ✓ cursor ✓
macOS Linux Windows Free forever. Open source. MIT license.
0 min
to set up
<0ms
context assembly
0
data sent anywhere
∞
AI tools supported
Built for systems thinkers
Every developer
knows this feeling.
“The codebase shows what was built. It never shows why.”
“Every new AI session is a new hire who hasn’t read the docs.”
“The comment says “do not remove”. Nobody knows why.”
“Your best architectural decision lives in a Slack thread nobody can find.”
“You shouldn’t have to be the context manager.”
“The junior asked why we use this pattern. I said “historical reasons”.”
“The engineer who understood this system left six months ago.”
“We chose this approach for a reason. I just can’t remember what it was.”
Your codebase memory.
Yours to keep.
Local. Private. Open source. No account required. No cloud. No subscription. Just your AI tools, finally remembering.
MIT License · Your code never leaves your machine · v0.1.0