+------------------------------------------+ | teammateX — a teammate, not a chatbot. | +------------------------------------------+
Connect GitHub and it pulls in all of your repositories — every one of them — then starts learning and onboarding itself: it parses every file, mines the git history, and builds a knowledge graph of functions, call edges and owners. Then it joins the team: answers questions with file-and-line receipts, traces bugs to the person who owns them, and opens real pull requests.
Self-hosted — your code never leaves your servers.
Pulls every repo from your GitHub, parses every file and mines every commit into a graph + embeddings. New engineers stop spending weeks building a mental model — it's already built, and it stays current.
Every reply is grounded in real lookups — semantic search, graph queries, blame. You get the file and the line, not a hallucinated guess.
Ownership is mined from git history, weighted by commits. "Who should review this?" and "who do I ask?" stop being tribal knowledge.
Call edges in the graph answer "what depends on this?" before you touch it. Fewer surprise breakages from innocent-looking changes.
Edits files, runs tests and lint, branches, commits, opens the PR itself. Small fixes go from "someday" to "merged" without stealing an engineer's afternoon.
Standup, task board, weekly digest — deterministic pages fed by real data, postable to Slack. Status meetings write themselves.
Every LLM call metered with a monthly budget guardrail; every agent action audited; live container logs in the UI. A self-hosted agent never becomes a surprise bill or a mystery.
Runs on your infrastructure with your LLM key — or a fully local model via Ollama. Nothing phones home; with local models, nothing leaves the box at all.
Add one repo at a time — or connect GitHub, click “Browse my repositories,” and bulk-select everything you own. Each repo rides a pipeline that turns source code into queryable knowledge. Progress is shown per stage with real status — failed stages retry.
then a background poller re-syncs every 15 minutes, so its knowledge tracks reality without a manual re-onboard.
A real agent loop: think, call a tool, read the result, keep going until it can answer. Exactly like a senior engineer with a terminal.
read_file write_file edit_file list_directory glob_search grep_searchcreate_branch commit_files create_pr get_diff get_blame get_commit_log list_prssemantic_search graph_query find_owner find_dependents find_dependencies get_architecture trace_issuewrite_note search_notesrun_command run_tests run_lint http_request schedule_task web_searchwrite_note / search_notes give the team a durable memory that survives across conversations and links into the graph.
pgvector answers "what code means this?" — Neo4j answers "how does it connect?" Vector search guesses by meaning; the graph knows by structure. Together they keep every answer grounded.
your question
|
v
+-------------+ 28 tools
| agent | -----------------------+
+-------------+ |
| | v
v v +--------------+
+-----------+ +-----------+ | git + gh |
| pgvector | | neo4j | | tests, lint |
| "what | | "what | | real PRs |
| means?" | | connects?"| +--------------+
+-----------+ +-----------+
semantic search CALLS / OWNS / PART_OF
+----------------------------------+
Browser --TLS--> | Caddy (reverse proxy :80/:443) |
+---------------+------------------+
/api/* | everything else
+----------------------+-----------------------+
v v
+-----------------+ +--------------------+
| FastAPI :8000 | | Next.js 14 :3000 |
| (REST + auth) | | (App Router UI) |
+--------+--------+ +--------------------+
|
+------------+---------------+-------------+-------------+
v v v v v
+--------+ +-----------+ +-----------+ +----------+ +----------+
|postgres| | neo4j | | redis | | celery | | cloned |
|pgvector| | knowledge | | broker + | | worker + | | repos |
| + ORM | | graph | | cache | | beat | | /data |
+--------+ +-----------+ +-----------+ +----------+ +----------+
LLM via LiteLLM --> DeepSeek · OpenAI · Anthropic · Groq · Ollama (local)
Observability --> Prometheus · Grafana · Loki/Promtail · Flower · node-exporter
The whole stack runs on your infrastructure via Docker Compose. Code, embeddings and graph stay put. Nothing phones home.
OpenAI, Anthropic, DeepSeek, Groq — or a local Ollama model. With local embeddings (the default) plus a local model, nothing leaves the box, full stop.
Every endpoint requires login; auth rides an HttpOnly cookie XSS can't steal. Account creation is admin-only. A reachable instance can't be self-registered into.
API keys and tokens are stored server-side and masked on read — never echoed back to the client. Rotate keys through the UI without redeploying.
Requirements: Docker + Compose v2, ~6 GB free RAM, one LLM key (or a local Ollama model).
open localhost:3000, grab the one-time admin password from the api logs, then: name your teammate → add an LLM key → connect GitHub → add repositories. minutes later it has read its first repo.
a read-only GitHub token is enough — it can pull, learn and answer with read access alone. grant write scope only if you want it opening PRs.
git and gh itself: branch → commit → PR. It needs a GitHub token with write scope; a read-only token lets it clone and read, but a push will 403.One compose file. Your servers. A teammate that already did the onboarding.