AI-first software stack
Start-here path for newcomers, layer map, card defaults and alternatives, a collapsible beginner glossary (plain English per tool), workflow, pitfalls, practices, and a flat tool index—skim first, then go deep where you need it.
Codevensiva
Overview
Plain-language gist: this page is a menu of building blocks teams combine when AI is part of the product—databases, assistants, document search, browsers, login, payments, and how you ship it all. You are not meant to read every card today; skim, then zoom into the layer that matches what you are building.
Start here (if you are new)
- Pass 1 — Orientation (~5 minutes). Read the layer map table and the key concepts bullets. Goal: see that agents and RAG sit on top of storage, APIs, and hosting—not the other way around.
- Pass 2 — One layer only. Open just the section that matches your question (for example Core infrastructure if you are choosing a database, or RAG & data if you want “chat with our PDFs”). Ignore the rest until you need it.
- Pass 3 — Look up names. When a logo or label confuses you, use the beginner glossary (expand one row at a time). On the blog version, many card links jump there automatically; use ← Back to stack map inside a glossary panel to return to the cards.
Tiny jargon decoder: RAG = Retrieval-Augmented Generation (answers that use your documents, not only the model’s training data). Agent = software that plans steps and calls tools (APIs, DBs, browsers). LLM = Large Language Model (the model behind chat). MCP = a common way to plug tools into assistants—see the glossary entry.
This reference groups tools the way you would sketch a system on a whiteboard: foundation first, then agents, retrieval and knowledge, live web access, the product layer, how you ship it, and how you run models privately. Each bundle uses cards—category, primary pick (checkmark), optional hosts, alternatives with labels, and bullets—so you can scan quickly, compare trade-offs, and jump to vendor docs when a row matches your constraints.
Use it in two modes: greenfield (pick defaults per layer and move on) or gap-fill (you already have a database or host—find what typically sits next to it in an AI-first system). The flat tool index at the end is for onboarding and vendor comparison, not ranking within a category. New to the names? Open the beginner glossary for short, plain-English explanations you can expand one at a time.
- Audience: Builders shipping software with AI-assisted development and AI-native behavior (agents, tools, RAG, evals).
- Outcomes: A coherent mental model of layers and dependencies; sane defaults per concern; enough context to justify exceptions (compliance, latency, team skills, existing licenses).
- Not covered here: Fine-grained pricing, regional data residency, or vendor SLAs—those change often; treat cards as architectural hints, not procurement truth.
Quick path through this page
- Brand new? Skim Start here (if you are new) first—then continue this list.
- Orientation — Read the layer map once so you know what “sits under” agents and RAG.
- Foundation — Core infrastructure: data, cache, how you code, how you prototype.
- Intelligence — Agents then RAG & data: frameworks, traces, extraction, vectors, graphs, evals.
- World access — Web automation: batch crawl vs. live tools vs. hosted browsers.
- Product & ship — Full-stack and Deploy: API, auth, UI, money, hosts, containers, CI.
- Private AI — Local & self-hosted when models or data must stay on your metal.
- Execution & lookup — Suggested workflow, pitfalls, practices, the index; use the beginner glossary when a name is unfamiliar; finish with the summary.
How the layers depend on each other
Higher layers assume lower layers exist in some form. You can swap vendors within a cell; the dependency direction is what matters for design reviews and incident response.
| Layer | Role | Typical inputs |
|---|---|---|
| Core | Durable state, speed, dev velocity, fast experiments | Product requirements, team language preferences, budget for managed vs. DIY |
| Agents | Tool-calling logic, multi-step workflows, delegated auth, traces | Models and API keys, core data for grounding, product events |
| RAG & data | Ingest, chunk, embed, remember, graph, measure quality | Files and URLs, Postgres (or dedicated vector DB), eval datasets |
| Web | Fetch or drive the public web safely and repeatably | URLs, crawl policies, sometimes third-party automation vendors |
| Full-stack | Human-facing product, auth, payments, analytics | Agent APIs from above, design system, compliance needs |
| Deploy | Reproducible environments, CI, GPU when needed | Container images, secrets, traffic and cost envelopes |
| Local AI | Air-gapped or cost-sensitive inference and chat | Hardware, model weights, internal proxies |
How to read the cards
For beginners: each card is a category (like “database”), not a product review. On the blog version of this article, many names link to the beginner glossary—open a row for plain English, then use ← Back to stack map (or your browser back button) to return to the cards. In this standalone HTML file, follow the same glossary links where you see them.
Each card is one concern (for example “database” or “observability”), not one vendor story. The ✓ line is the default pick for that concern when you have no strong reason to diverge. Alternatives are a small, opinionated sample—enough to frame trade-offs, not an exhaustive market map.
Vendor features, pricing, compliance, and regional availability change often—always verify against current documentation, your security review, and procurement rules before you commit.
Prerequisites
Mindset
- Capabilities over tools: standardize on what works for your team, but switch when another tool clearly wins on the dimension you care about (latency, compliance, hiring market, integration depth).
- Problems first: framework debates are cheap; customer and reliability problems are expensive—optimize the latter.
- Evidence for swaps: keep a one-page ADR when you change a layer so the next person knows why (and when to revisit).
Technical baseline
Comfort with the following makes this reference much easier to act on:
- SQL and one relational database — migrations, indexes, and basic query plans (most AI app patterns still land in Postgres).
- Git + CI — branches, pull requests, and a pipeline that runs tests on every push.
- Containers — build an image, pass env vars and secrets, read logs; you do not need to be a Kubernetes expert on day one.
- HTTP APIs — JSON request/response, auth headers, timeouts, and idempotency for anything agents call.
- One cloud account — enough to deploy a small API and a static front end, even if production later moves to a different region or provider.
If you are not there yet
That is normal. Use this page as a map of what to learn next, not a gate. Pick one foundation (often SQL or “how HTTP APIs work”), revisit Core infrastructure when you are ready, and lean on the glossary whenever a name appears in the wild.
Key concepts
- AI-first: AI-assisted development (how you write and review code) and AI-native products (agents, tools, streaming UX, eval loops) are defaults—not a late add-on when “we have time.”
- Layers (pipeline mental model): Core stores state and accelerates iteration → Agents orchestrate tools and models → RAG & data ground answers in your corpus → Web reaches live or hostile surfaces → Full-stack exposes humans and billing → Deploy ships reproducibly → Local AI covers private inference when required.
- Hosted vs. open: managed services reduce undifferentiated ops; open-source and portable artifacts help with reproducibility, air-gaps, and unit economics. Most teams mix both (for example managed Postgres + self-hosted automation or eval workers).
- Prototype → code → product UI: validate flows and prompts in a visual tool, implement in code with tests and types, then add a thin chat UI (for example Streamlit) before you invest in a full SPA—each step de-risks the next.
- Observability is not optional for agents: traces tie prompts, tool calls, and failures to dollars and latency; without them you cannot tune prompts or prove reliability in production.
Core infrastructure
The foundation that powers storage, cache hot paths, how you build with AI assistants, and how you validate ideas before you lock them into code. Get this layer boring and reliable—everything upstream assumes your data and dev loop are trustworthy.
The foundation that powers everything
MongoDB
Firebase
- One relational store for app data and many RAG patterns.
- Scales with mature ops playbooks; strong ecosystem.
- Neon and Supabase reduce hosting friction while staying “just Postgres.”
- Neon vs. Supabase: both are valid Postgres fronts—compare branching/scale features, auth bundling, and how much control-plane you want in the same vendor as your app DB.
Memcached
- Low-latency sessions, queues, and hot read paths.
- Valkey is a Redis-compatible OSS option where licensing matters.
- Define TTLs and key namespaces early—agent workloads can create hot keys and noisy neighbors without guardrails.
- Strong day-to-day coding agent UX; slash commands and skills.
- Archon adds RAG-style context and structured task tracking beside the IDE.
- Keep prompts, decisions, and links in versioned artifacts so the assistant (and humans) can resume work without Slack archaeology.
General AI agents
The default stack for single agents (typed tools, providers, validation), multi-agent coordination when state and routing get hard, safe access to user-connected systems, and production traces so you can debug and optimize spend. Treat “framework + observability + auth” as one unit—dropping any leg tends to hurt you in prod.
The foundation for building any agent
- Typed models and validation across providers and tools.
- Good fit when you want structure without heavy ceremony.
- “Raw LLM calls” stay valid for tiny scripts—reach for a framework when you need tool schemas, retries, and multi-provider swaps in one codebase.
- State, branching, human-in-the-loop, and durable execution.
- Use when coordination—not a bigger model—is the hard part.
- Prefer a single agent until traces show repeated hand-offs, contention, or long-lived workflows that benefit from a graph.
- Authorization for agents is underrated until you ship to real users.
- Pair with MCP so assistants call only scoped, audited actions.
- Model user consent, token refresh, and least-privilege scopes explicitly—agents magnify the blast radius of OAuth mistakes.
RAG & data
Ingest messy documents and sites, store embeddings where they fit your query patterns, add long-term memory and knowledge graphs when semantics matter, then measure quality so improvements are data-driven—not vibe-driven. Separate “offline ingest into a corpus” from “live web tools” (covered again under Web automation) so pipelines stay understandable.
From files and pages to vectors, memory, and evaluation
- PDFs, tables, and layouts that break naive text extractors.
- Pair with chunking and metadata policies you control in code.
- Measure extraction quality on a fixed eval set whenever you change parsers or models—regressions are easy to miss by eye.
- Rule of thumb: rich files → Docling; public sites → Crawl4AI.
- Clean HTML and LLM-assisted extraction for agent-sized payloads.
- Respect robots, terms of service, and rate limits—crawl politely and log source URLs for auditability.
- Keeps embeddings next to transactional data when possible.
- Dedicated vector DBs trade ops surface for raw query speed.
- Long-term memory belongs here architecturally—treat it as retrieval over structured conversation history, not a magic side channel.
- Graphs for entities and relationships; Memgraph and FalkorDB are common swaps.
- Ragas for RAG metrics; Brave vs Perplexity trades latency for depth.
- Check graph licensing and ops before you commit—commercial Neo4j deployments have different constraints than hobby experiments.
Web automation
Separate batch ingest (build a corpus ahead of time, store in your DB) from live tools (agents fetch or act on the web during a session). Crawlers and headless browsers solve different problems; mixing them confuses latency, compliance, and retry semantics—pick the row that matches when data is needed and who owns the risk.
Crawl, scrape, script the browser, or rent a cloud browser
- Great default for public pages you own or may legally index.
- Prefer deterministic schedules and backoff for bulk ingest; agents calling crawls live should have strict timeouts and circuit breakers.
Chrome
- Platforms with aggressive bot defenses or terms that forbid naive crawling.
- Plan compliance and robots policy before you automate.
- Budget for maintenance when selectors and anti-bot flows change—vendor APIs can be cheaper than endless break-fix scraping.
Puppeteer
Selenium
- Reliable end-to-end tests and scripted flows.
- Playwright MCP helps assistants validate UI visually.
- Keep selectors and fixtures stable—flaky E2E erodes trust in both humans and agents.
- Managed sessions, recordings, anti-bot helpers for agent-driven browsing.
- Built on Playwright concepts; exportable automation snippets.
- Review recordings when tasks fail silently—hosted browsers shift debugging from “grep logs” to “replay the session.”
- Director and Stagehand (including Stagehand MCP) are part of the Browserbase ecosystem on this map; confirm current names, packaging, and licensing on Browserbase and Stagehand docs—they evolve faster than static references.
Full-stack application
APIs, auth, UI, quick agent surfaces, observability, and payments—the product layer that turns agent behavior into something customers can trust and pay for. Favor boring choices here (Postgres, standard OAuth patterns, one design system) so your differentiation stays in agent quality and domain logic, not in bespoke auth or layout bugs.
From API to pixels and revenue
- Python-first stack; Express when the team is TypeScript end-to-end.
- OpenAPI-style contracts and shared error shapes make agents and humans easier to debug across services.
- Supabase for fast defaults; Clerk/Okta when SSO and policy engines matter.
- Separate human login from agent-to-tool OAuth (Arcade-style)—users should see consent surfaces they understand.
- Agentic builders (Lovable, Bolt, bolt.diy) for fast UI drafts.
- Streamlit before a SPA when validating agent UX in Python.
- Treat builder output as prototypes—promote patterns into your design system before you depend on them for compliance-heavy UI.
- Errors, product analytics, and billing are part of the agent product, not an afterthought.
- Wire billing webhooks and entitlement checks into the same traces you use for agents—refunds often start as “the agent did something surprising.”
Deploy & infrastructure
Where binaries run, how GPUs are rented when batch or training workloads need them, and how CI keeps drift under control. Containers are the contract between dev and prod; Actions (or equivalent) encode what must be true before merge. Start with a PaaS-shaped path until constraints (VPC peering, custom AMIs, regulated artifacts) push you toward VMs or hyperscalers.
Hosts, clouds, GPUs, containers, CI, tests
- Git deploys, workers, cron, static sites—good default before bespoke k8s.
- Define environments (preview vs. prod), secrets rotation, and health checks explicitly—PaaS is simple until the first incident.
- Reach for strict SLAs, compliance envelopes, or bespoke networking here.
- Account for egress and cross-region latency when agents stream tokens or pull large artifacts from object storage.
- Spot and budget tiers trade reliability for cost—label workloads accordingly.
- Snapshot images and pin driver/CUDA stacks so a notebook that worked Tuesday still works Thursday.
- Container images kill “works on my machine” drift.
- Let agents draft Actions YAML and tests—humans still own merges.
- Run linters, type checks, and a minimal smoke test on every PR; AI review tools catch different failure modes than static analysis.
Local & self-hosted AI
Chat with local models, terminate TLS at the edge you control, and compose Postgres, caches, automation, and observability on your own hardware—useful for air-gaps, cost caps, or iterative research without cloud round-trips. Expect more ops work than managed stacks; invest in backups, updates, and capacity planning the way you would for any internal service.
Models, UI, TLS, and bundled stacks
- Local alternative to hosted chat UIs; pair with your own model gateway.
- Lock down admin endpoints and auth—homelab UIs are easy to expose accidentally when you punch holes for TLS.
- Quantized weights, multi-GPU, and simple CLIs for iterative experiments.
- Track VRAM and context limits per model; LiteLLM-style gateways help when you outgrow a single runtime.
- Automatic HTTPS and small config surface for homelab stacks.
- Put reverse proxies in front of every internal service—even “temporary” demos become permanent entry points.
- Common bundle: Postgres, Valkey, Flowwise, Langfuse, Crawl4AI, Ollama, Open WebUI—tune to your threat model.
- Add a self-hosted web search appliance (for example SearXNG-class) if you need offline retrieval.
- Version your compose files and pin image digests; “latest” tags make rollbacks painful when something upstream shifts.
Suggested workflow
A pragmatic path from idea to production UI without skipping safety or observability. Adjust cadence for your team size; the order matters more than the calendar.
- Discover and wire tools in n8n. Validate integrations, prompts, and branching with stakeholders before you invest in code structure. Export or screenshot flows so engineering inherits intent, not folklore.
- Implement in Pydantic AI (add LangGraph only after traces show real multi-step coordination). Co-locate tests for tools and schemas; treat tool contracts as part of your public API surface.
- Streamlit for internal dogfood. Give support, PM, and engineering a stable URL with auth appropriate for internal data. Decide UX metrics here before you polish pixels in React.
- Product SPA with React + Vite (and shadcn/Tailwind patterns). Use agentic builders for exploration, then consolidate components into your repo so design tokens and accessibility stay under review.
- Production hardening. Turn on Langfuse (or equivalent) before launch traffic; add Arcade (or your own OAuth) before any workflow touches real user accounts. Load-test tool latency and add backoff where external APIs are flaky.
Common pitfalls
- Tool obsession instead of shipping. Mitigation: time-box spikes; capture outcomes in a short ADR; default to the card’s primary pick unless you have a measured reason to diverge.
- Multi-agent by default. Mitigation: start single-agent; add a graph when you can point to concrete routing, state, or HITL requirements in traces.
- No production traces. Mitigation: ship observability with the first external pilot; correlate cost spikes to prompts and tool calls, not just “model got slower.”
- One crawler for every surface. Mitigation: separate batch RAG ingest from live browsing; escalate to Apify/Bright Data-class tooling when targets are hostile or contractual.
- Auth soup between humans and agents. Mitigation: separate end-user login (Supabase/Clerk/Okta) from delegated tool OAuth (Arcade-style); document which tokens agents hold and for how long.
Practices
- Stabilize deliberately: once a layer works in prod, freeze versions for a sprint or two; schedule upgrades instead of chasing every release note.
- Stay adaptable with evidence: when you swap a tool, record latency, cost, and developer-hours saved—otherwise debates stay opinion-based.
- Containerize everything that ships: devcontainers locally, images in CI, same artifact to prod—parity beats clever shell scripts.
- Human-in-the-loop for merges: let assistants draft Actions, tests, and migrations; require human review for auth, schema, and security-sensitive diffs.
- Runbooks for agents: document how to disable a tool, rotate keys, and drain queues when an integration misbehaves—agents amplify outages as well as wins.
Tool index (by area)
Flat grid of tools referenced earlier on this page—use it as a checklist when comparing vendors, onboarding teammates, or auditing what your repo actually depends on. Grouping follows the same layer order as the cards above; items are not ranked within a group.
Tip: when you adopt something new, add its owner, expected monthly cost band, and rollback plan next to the row in your internal wiki—future you will thank present you.
Hosting, data, cache, assistants, and quick automation loops.
-
PostgreSQL
Primary SQL database.
-
Neon
Hosted Postgres.
-
Supabase
Hosted Postgres, dashboard, auth helpers.
-
MongoDB
Document store alternative.
-
Firestore
Managed document store alternative.
-
Redis
Caching.
-
Valkey
Redis-compatible OSS cache.
-
Claude Code
AI coding assistant.
-
Archon
Knowledge and task layer beside the assistant.
-
Cursor
AI IDE assistant alternative.
-
Codex
Assistant alternative.
-
Claude Skills
Reusable skill packs in the assistant.
-
n8n
Workflow and agent prototyping.
-
Langflow
Visual automation alternative.
-
Flowwise
Visual automation alternative.
-
Self-hosted bundle
Postgres, Valkey, Flowwise, Langfuse, Crawl4AI, Ollama, Open WebUI, and related OSS in one compose.
Frameworks, protocols, delegated auth, and traces.
-
Pydantic AI
Typed agent framework.
-
Agno
Agent runtime and AgentOS (alternative framework).
-
LangGraph
Multi-agent orchestration and durable graphs.
-
CrewAI
Multi-agent alternative.
-
Pydantic AI graphs
Multi-agent option in the same framework.
-
Raw LLM calls
Minimal stack when a framework adds no value.
-
MCP (Model Context Protocol)
Tool and context wiring for assistants.
-
A2A
Agent-to-agent style protocols in some stacks.
-
AGUI
Agent UI protocol implementations.
-
Vercel
Streaming and deployment surface referenced with modern React stacks.
-
FastMCP
Lightweight Python MCP server patterns.
-
Arcade
OAuth, scoped tools, MCP server SDK.
-
Langfuse
Traces, cost, latency, evals, prompts.
-
LangSmith
Observability alternative.
-
Helicone
Gateway-style LLM observability.
Extract, embed, remember, graph, evaluate, search.
-
Docling
Structured extraction from complex documents.
-
LlamaIndex
RAG framework and ingestion helpers.
-
Unstructured
Document parsing alternative.
-
Crawl4AI
Site crawl and cleanup for LLMs.
-
PostgreSQL
App and metadata store.
-
pgvector
Vector search inside Postgres.
-
Qdrant
Dedicated vector database.
-
Pinecone
Managed vector database.
-
Mem0
Long-term conversational memory.
-
Zep
Memory service alternative.
-
Neo4j
Property graph database.
-
Memgraph
Graph engine alternative.
-
FalkorDB
Graph + Redis-style memory option.
-
Graphiti
Graphiti is Zep’s open-source temporal knowledge-graph memory for agents (episodes, hybrid retrieval); commonly backed by Neo4j—do not confuse the name with the misspelling “Graffiti” in some community posts.
-
LightRAG
Combined vector and graph RAG approach.
-
Ragas
RAG evaluation metrics and synthetic tests.
-
Brave Search
Web search API.
-
Perplexity
Research-oriented search interface.
Crawl, scrape, drive browsers, or run them in the cloud.
-
Crawl4AI
Live crawl tool for agents.
-
Firecrawl
Crawl and extract alternative.
-
Apify
Actors and datasets for guarded sites.
-
Bright Data
Scraping and proxy infrastructure.
-
Playwright
Cross-browser automation.
-
Playwright MCP
MCP bridge for assistants.
-
Puppeteer
Chromium automation alternative.
-
Selenium
Classic browser automation.
-
Browserbase
Hosted browser fleet for agents.
-
Stagehand MCP
Natural-language browser control.
-
Director
Browserbase guided web tasks and exports (same vendor family as Stagehand).
APIs, auth, UI, shipping, and payments.
-
FastAPI
Python API framework.
-
Flask
Python microframework.
-
Express
Node HTTP API framework.
-
PostgreSQL
Relational data.
-
Supabase
Auth and Postgres hosting.
-
Neon
Serverless Postgres hosting.
-
Enterprise IdP
SAML, OIDC, MFA via your chosen vendor.
-
Clerk
Hosted auth with strong DX.
-
Okta
Enterprise identity platform.
-
React
UI library.
-
Vite
Frontend toolchain.
-
Next.js
Full-stack React framework.
-
Vue
UI framework alternative.
-
shadcn/ui
Copy-in component patterns.
-
Tailwind CSS
Utility-first styling.
-
Lovable
Agentic UI builder.
-
Bolt.new
Agentic UI builder.
-
bolt.diy
Open agentic UI builder.
-
Streamlit
Python-native UI for agents.
-
Sentry
Error monitoring.
-
PostHog
Product analytics.
-
Google Analytics
Traffic analytics.
-
Stripe
Payments.
-
Lemon Squeezy
Merchant-of-record alternative.
-
Paddle
Merchant-of-record alternative.
Hosts, clouds, GPUs, containers, CI, and tests.
-
Render
PaaS with YAML and git deploys.
-
Fly.io
PaaS alternative.
-
Netlify
Static and edge hosting.
-
AWS
Hyperscaler.
-
GCP (Google Cloud Platform)
Hyperscaler.
-
RunPod
GPU rentals.
-
TensorDock
Budget GPU provider.
-
Lambda Labs
GPU cloud.
-
DigitalOcean
VMs and managed services.
-
Hostinger
VPS hosting.
-
Hetzner
EU-centric VPS value.
-
Docker
Containers.
-
Podman
Rootless container engine.
-
GitHub
Source hosting.
-
GitHub Actions
CI/CD.
-
pytest
Python tests.
-
Jest
JavaScript tests.
-
CodeRabbit
AI-assisted pull request review.
Models, chat UIs, proxies, and compose-yourself stacks.
-
Open WebUI
Local chat front end.
-
AnythingLLM
Local workspace alternative.
-
SearXNG-class search
Self-hosted metasearch for private retrieval.
-
Ollama
Local model runner.
-
vLLM
High-throughput inference server.
-
LiteLLM
Unified LLM gateway.
-
Caddy
Automatic HTTPS reverse proxy.
-
Traefik
Dynamic edge proxy.
-
NGINX
Mainstream reverse proxy.
When agents touch real user data, you wire OAuth and vendor SDKs—these are examples of destinations, not mandatory stack components.
-
Gmail, Slack, Reddit
APIs often shown in agent demos.
-
SAML, Active Directory
SAML is vendor-neutral; this row pairs it with Active Directory–style directories (often Microsoft Entra ID) as a common enterprise pattern—the icon is illustrative, not a claim that SAML is Microsoft-specific.
Alphabetical index
A2A · AGUI · Agno · AnythingLLM · Apify · Arcade · Archon · AWS · Active Directory · Bolt.new · bolt.diy · Brave Search · Bright Data · Browserbase · Caddy · Clerk · Claude Code · Claude Skills · CodeRabbit · Codex · Crawl4AI · CrewAI · Cursor · DigitalOcean · Director · Docker · Docling · Enterprise IdP · Express · FastAPI · FastMCP · Firecrawl · Firestore · Flask · Flowise · Flowwise · Fly.io · FalkorDB · GCP (Google Cloud) · GitHub · GitHub Actions · Gmail · Graphiti · Hetzner · Helicone · Hostinger · IBM · Jest · Lambda Labs · LangChain · Langflow · Langfuse · LangGraph · LangSmith · Lemon Squeezy · LightRAG · LiteLLM · Lovable · MCP · Mem0 · Memgraph · MongoDB · n8n · Neo4j · Neon · Netlify · Next.js · NGINX · OAuth · Okta · Ollama · Open WebUI · Paddle · Perplexity · pgvector · Pinecone · Playwright · Playwright MCP · Podman · PostHog · PostgreSQL · Pydantic AI · pytest · Qdrant · Ragas · Reddit · React · Redis · Render · RunPod · SAML · Selenium · Sentry · shadcn/ui · Slack · Stagehand MCP · Streamlit · Stripe · Supabase · Tailwind CSS · TensorDock · Traefik · Unstructured · Valkey · Vercel · vLLM · Vite · Vue · Zep
Beginner glossary
Short, jargon-light explanations for names in this reference. Open any row to read what it is, why the stack mentions it, and what to do first if you are learning. This is orientation, not vendor documentation—always confirm details in official docs before production decisions.
#primer-… anchors, then jump to the layered cards (core, agents, RAG, web, product, deploy, local) when you are ready to compare primary vs alternative picks.
Protocols & standards
Vocabulary that shows up across several layers—auth, observability, and agent wiring.
A2A Agent protocol
In plain English: A2A (agent-to-agent) describes patterns and emerging standards for one autonomous agent to call or delegate work to another agent safely, with clear boundaries and credentials.
On this map: This stack treats A2A as architectural vocabulary: your services, tools, and workflows should assume multiple actors, not a single monolithic chatbot.
If you are new: Until you have two real agents that must coordinate, you can ignore the acronym and focus on clear APIs, auth, and logs between components.
AGUI Agent ↔ UI
In plain English: AGUI-style thinking covers protocols and patterns where an agent streams structured actions or state to a user interface instead of only returning plain text.
On this map: Referenced here as part of the modern “agentic product” surface: chat plus widgets, approvals, and tool progress indicators.
If you are new: If you only ship a text box today, remember that production UIs usually need loading states, partial results, and human-in-the-loop confirmations.
MCP Model Context Protocol
In plain English: MCP is an open protocol (popularized by Anthropic’s ecosystem) for tools, data sources, and IDEs to expose structured capabilities that a model or agent can call in a standard way.
On this map: Playwright MCP, FastMCP, and similar entries are concrete implementations—think “USB-C for agent tools” rather than one vendor product.
If you are new: Learn one MCP server end-to-end (for example filesystem or browser) before you design dozens of custom tools.
FastMCP Python MCP toolkit
In plain English: FastMCP is a Python-oriented way to build MCP servers quickly with decorators and typed inputs so your tools are easy to test and document.
On this map: Appears alongside general MCP mentions when teams standardize on Python for agent backends.
If you are new: Use it when your engineers already live in FastAPI or Pydantic and want the same ergonomics for tool definitions.
OAuth Authorization
In plain English: OAuth 2 (often with OpenID Connect) is how users delegate limited access to your app without handing you their main password—think “Sign in with Google” or “Connect Slack”.
On this map: Arcade and similar layers sit on top of OAuth so agents do not store long-lived passwords for Gmail, Slack, or Reddit integrations.
If you are new: Never teach an LLM to “remember” a password; always use delegated tokens with scopes and rotation.
SAML Enterprise SSO
In plain English: SAML is an XML-based federation protocol enterprises use so employees sign in once (single sign-on) and access many internal apps.
On this map: Paired on this map with Active Directory–style directories as a common pattern; SAML itself works with many vendors, not only Microsoft.
If you are new: If your app is B2B, plan early for SSO requests—retrofitting SAML cleanly is harder than baking it into routing and session design.
pgvector Postgres extension
In plain English: pgvector adds vector similarity search to PostgreSQL so embeddings live beside normal rows, joins, and transactions in one database engine.
On this map: Shown as “Postgres + pgvector” so beginners do not imagine a separate mystery database—vectors are just another index type on Postgres.
If you are new: Start with modest embedding dimensions and index tuning guidance from the extension docs; measure recall before you chase micro-optimizations.
Data, memory & ingestion
Where facts live, how they are chunked, and how retrieval stays honest.
PostgreSQL Relational database
In plain English: PostgreSQL (Postgres) is a mature open-source relational database known for reliability, rich SQL, and extensions—pgvector is one of them.
On this map: This stack’s default system of record for AI apps: users, billing, permissions, and often RAG chunk metadata all fit naturally.
If you are new: Learn SQL basics, migrations, and backups before you add agents; agents amplify data mistakes as fast as they amplify good queries.
Related: Core infrastructure.
Neon Hosted Postgres
In plain English: Neon is a serverless-oriented managed Postgres platform with branching and scale-to-zero style workflows aimed at developers shipping web apps quickly.
On this map: Listed as a common host when you want Postgres without running your own VMs.
If you are new: Great for prototypes and many production workloads; still read their limits around connections, pooling, and long-running analytics jobs.
Related: Core infrastructure.
Supabase Backend platform
In plain English: Supabase wraps Postgres with auth, storage, realtime channels, and auto-generated APIs so you ship backends faster than wiring every piece by hand.
On this map: Often paired with React or Next.js in this map as the “batteries included” data and auth layer.
If you are new: Treat Row Level Security policies as part of your application code—review them in PRs the same way you review Python or TypeScript.
Related: Core infrastructure.
Redis In-memory data store
In plain English: Redis is an in-memory key-value store used for caches, rate limits, job queues, pub/sub, and session storage with very low latency.
On this map: Sits next to Postgres in many AI stacks for ephemeral state and cross-request coordination.
If you are new: Decide TTLs and eviction policies up front; silent cache expiry bugs confuse both humans and agents.
Related: Core infrastructure.
Valkey Redis-compatible OSS
In plain English: Valkey is an open-source fork/community continuation of the Redis protocol ecosystem, offering a Redis-compatible API for caches and queues.
On this map: Mentioned as an alternative when teams want OSS-first hosting or compatibility without tying licensing discussions to a single vendor narrative.
If you are new: If your client libraries speak Redis wire protocol, Valkey is often a drop-in conceptually—still verify version support in staging.
Related: Core infrastructure.
MongoDB Document database
In plain English: MongoDB stores JSON-like documents with flexible schemas and horizontal scaling patterns.
On this map: Alternative data store when document shape variability dominates strict relational modeling.
If you are new: Schema discipline still matters—indexes and validation rules save you from silent performance cliffs.
Related: Full-stack application.
Firestore Google document DB
In plain English: Firestore is Google’s managed document database with realtime listeners and mobile SDKs.
On this map: Alternative when you are already embedded in Firebase/GCP ecosystems.
If you are new: Understand query limitations and pricing for read-heavy agent logs.
Related: Full-stack application.
Docling Document parsing
In plain English: Docling focuses on high-quality parsing of complex office and PDF layouts into structured text and tables for downstream RAG.
On this map: Primary ingest tool in the RAG row for “messy” documents.
If you are new: Compare a few real customer PDFs side by side with simpler parsers—layout fidelity drives answer quality.
Related: RAG & data.
Unstructured ETL for documents
In plain English: Unstructured.io offers libraries and APIs to chunk and normalize content from many file types before vector indexing.
On this map: Alternative ingest path when you want a broad connector matrix more than layout-perfect PDF science.
If you are new: Watch cost and latency when calling hosted APIs on large corpora—batch and cache aggressively.
Related: RAG & data.
Crawl4AI Web crawl for AI
In plain English: Crawl4AI is an open toolkit oriented toward crawling and extracting web pages for AI pipelines with Playwright-style control.
On this map: Default for ingesting public sites you are allowed to index into your corpus.
If you are new: Respect robots.txt, terms of service, and rate limits—legal risk is not an “LLM problem”.
Related: RAG & data.
Firecrawl Web → clean text API
In plain English: Firecrawl turns URLs into cleaned markdown or structured content via an API, reducing bespoke scraping code.
On this map: Alternative to Crawl4AI when you prefer a hosted extraction service.
If you are new: Cache results and handle JavaScript-heavy sites explicitly—magic “just fetch URL” rarely scales.
Related: Web automation.
Mem0 Long-term memory
In plain English: Mem0 provides patterns and services for persisting conversational memory and facts so agents recall context across sessions.
On this map: Vector-and-memory row alternative to only stuffing everything into the prompt window.
If you are new: Decide what is allowed to be remembered forever vs session-scoped—privacy policies depend on it.
Related: RAG & data.
Zep Memory platform
In plain English: Zep offers managed memory and context services for agents, including Graphiti’s temporal graph memory story on the OSS side.
On this map: Appears next to Graphiti in vector/graph discussions.
If you are new: Read Zep vs self-hosted Graphiti trade-offs for compliance and data residency.
Related: RAG & data.
Graphiti Temporal graph memory
In plain English: Graphiti (Zep, open source) builds time-aware knowledge graphs for agents on top of databases like Neo4j, tracking how facts evolve.
On this map: Paired with Neo4j in this map for graph-heavy agent memory—not the same spelling as informal “Graffiti” typos in blogs.
If you are new: Model “episodes” of new information and how they invalidate older edges—tests here catch subtle regressions.
Related: RAG & data.
Neo4j Graph database
In plain English: Neo4j stores data as nodes and relationships, ideal for traversals like “friends of friends” or knowledge graphs.
On this map: Default graph engine in the RAG/quality row when relationships matter as much as vector similarity.
If you are new: Learn Cypher basics and index patterns—graph queries can be fast or catastrophic without planning.
Related: RAG & data.
Memgraph Graph database
In plain English: Memgraph is a high-performance in-memory graph database compatible with many Cypher workloads, aimed at real-time analytics.
On this map: Alternative graph engine when latency and throughput dominate licensing discussions.
If you are new: Validate operational tooling backup/restore story vs your Neo4j experience.
Related: RAG & data.
FalkorDB Graph + Redis module
In plain English: FalkorDB extends Redis-style deployments with graph capabilities, useful when you already run Redis-class infrastructure.
On this map: Alternative when teams want graph queries close to existing cache clusters.
If you are new: Understand persistence configuration—ephemeral Redis defaults and durable graphs conflict if misconfigured.
Related: RAG & data.
LightRAG Graph + vector RAG
In plain English: LightRAG is a research-oriented approach combining vector retrieval with graph structures for richer context assembly.
On this map: Text-only alternative chip when you experiment beyond classic chunk-and-embed pipelines.
If you are new: Treat papers and repos as moving targets—pin commits and reproduce results on your own corpus.
Related: RAG & data.
Qdrant Vector database
In plain English: Qdrant is a dedicated vector search engine with filtering, hybrid search options, and self-hosted or cloud offerings.
On this map: Alternative when embeddings are huge or query QPS outgrows comfortable Postgres tuning.
If you are new: Running two systems (Postgres + Qdrant) means two backup strategies—plan operational ownership.
Related: RAG & data.
Pinecone Managed vectors
In plain English: Pinecone is a managed vector database service focused on low-latency similarity search at scale without operating raw indexes yourself.
On this map: Hosted alternative to self-managed Qdrant or pgvector at scale.
If you are new: Price by dimension and namespace design—bad namespaces become expensive clutter.
Related: RAG & data.
Brave Search Web search API
In plain English: Brave Search offers an API to query Brave’s web index, useful for agents that need fresh public web results with clear billing.
On this map: Search chip in RAG quality comparisons next to Perplexity-style research tools.
If you are new: Log queries and cap spend—agents can loop into expensive search spirals.
Related: RAG & data.
Perplexity AI research / search
In plain English: Perplexity provides consumer and API interfaces that combine search with synthesized answers—often used for research-heavy agent steps.
On this map: Alternative when depth and citations matter more than minimal latency.
If you are new: Read API terms for redistribution and caching—some answers are not yours to store forever.
Related: RAG & data.
Ragas RAG evaluation
In plain English: Ragas provides metrics and helpers to evaluate retrieval quality, faithfulness, and answer relevance for RAG pipelines.
On this map: Quality row alongside Docling and graph tooling—measure before you tune embeddings blindly.
If you are new: Start with a fixed golden set of questions your product actually sees—not only demo trivia.
Related: RAG & data.
Agents, models & glue
Frameworks and services that let models call tools safely and repeatably.
Pydantic AI Python agent framework
In plain English: Pydantic AI is a framework for building typed, structured agents and tools in Python with validation and good editor support via Pydantic models.
On this map: Primary agent row for Python-first teams who want explicit schemas for tool inputs and outputs.
If you are new: Define tool contracts in types first; let the model fill fields once the shape is unambiguous.
Related: AI agents.
LangChain Agent / LLM composition
In plain English: LangChain is a popular library ecosystem for composing chains, tools, retrievers, and agents around LLM providers.
On this map: Appears as an alternative when teams want maximum community examples and integrations.
If you are new: Pin versions and trim imports—large dependency trees make upgrades painful if you copy every tutorial block.
Related: AI agents.
LangGraph Agent orchestration
In plain English: LangGraph models agent workflows as graphs with cycles, branches, and human checkpoints—useful for non-trivial multi-step processes.
On this map: Recommended when coordination, retries, and state machines matter more than a single linear prompt.
If you are new: Draw the graph on paper before you code; ambiguous state transitions become expensive bugs in production.
Related: AI agents.
Langflow Visual LLM flows
In plain English: Langflow is a visual builder for LangChain-style flows so non-developers can experiment and developers can scaffold quickly.
On this map: Alternative UI for wiring tools and models without only writing code.
If you are new: Export or document flows as code for production—drag-only systems are hard to review in Git.
Related: AI agents.
Langfuse LLM observability
In plain English: Langfuse records traces, costs, latencies, and evaluations for LLM calls so you can debug prompts and tool loops like traditional APM.
On this map: Primary observability pick in the agents layer of this map.
If you are new: Instrument the first happy path first; do not wait until customers report “sometimes wrong”.
Related: AI agents.
LangSmith LangChain tracing
In plain English: LangSmith is LangChain’s hosted tracing, evaluation, and monitoring platform for chains and agents built in their ecosystem.
On this map: Alternative when you are already standardized on LangChain/LangGraph end-to-end.
If you are new: Connect tracing keys per environment so staging experiments never pollute production dashboards.
Related: AI agents.
Helicone LLM proxy / observability
In plain English: Helicone sits as a proxy or lightweight integration in front of LLM calls to log usage and metadata with minimal code changes.
On this map: Alternative observability path when you want provider-agnostic request logging quickly.
If you are new: Understand what payloads pass through a proxy—redact PII at the edge.
Related: AI agents.
LiteLLM Unified LLM gateway
In plain English: LiteLLM provides a single OpenAI-compatible API surface that routes to many providers, simplifying keys, fallbacks, and budget controls.
On this map: Gateway layer so services do not hardcode one vendor’s SDK everywhere.
If you are new: Centralize rate limits and per-team budgets here instead of scattering them in app code.
Related: AI agents.
CrewAI Multi-agent framework
In plain English: CrewAI frames work as cooperating roles (a “crew”) with tasks, tools, and handoffs—useful for narrative-style agent demos and some production workflows.
On this map: Alternative agent topology when role specialization is clearer than one mega-agent.
If you are new: More agents is not automatically better—each adds latency, failure modes, and coordination overhead.
Related: AI agents.
Agno Lightweight agents
In plain English: Agno is a newer lightweight Python agent toolkit emphasizing simple agents, teams, and model routing with minimal ceremony.
On this map: Alternative when you want a smaller conceptual surface than larger frameworks.
If you are new: Validate maturity against your timeline—smaller frameworks move fast but may have fewer Stack Overflow answers.
Related: AI agents.
Arcade Delegated auth for tools
In plain English: Arcade helps agents call third-party APIs with user-delegated auth flows instead of static API keys sitting in prompts.
On this map: Security row for Gmail, Slack, Reddit-style integrations in agent demos.
If you are new: Read each provider’s OAuth consent screens and token storage rules—users should know what an agent can do.
Related: AI agents.
Flowise Low-code LLM UI
In plain English: Flowise is an open-source node-based UI for building LLM flows with integrations similar in spirit to Langflow.
On this map: Automation alternatives row—check you are on flowiseai.com, not similarly named products.
If you are new: Export flows and back up credentials—low-code tools still need disaster recovery.
Related: Core infrastructure.
Flowwise Separate product
In plain English: Flowwise (flowwise.ai) is a different commercial product from Flowise—similar sounding name, different vendor and docs.
On this map: Listed to remind readers not to confuse repositories and Docker images by name alone.
If you are new: When copying tutorials, verify the homepage URL and npm package names character by character.
Related: Core infrastructure.
IBM Enterprise AI / cloud
In plain English: IBM provides watsonx and broader enterprise AI, hybrid cloud, and consulting offerings for regulated industries.
On this map: Icon chip alternative in agent/RAG rows for teams with existing IBM relationships.
If you are new: Map marketing names to concrete APIs you will call—enterprise catalogs are broad.
Related: AI agents.
Ollama Local model runtime
In plain English: Ollama downloads and runs open-weight models locally with a simple CLI and API, abstracting some GPU/CPU packaging pain.
On this map: Default “run models on your machine” story in the local layer.
If you are new: Model files are large; plan disk and version pinning for reproducible demos.
Related: Local & self-hosted AI.
vLLM Fast LLM serving
In plain English: vLLM is a high-throughput inference server for transformer models with optimizations like PagedAttention for many concurrent requests.
On this map: GPU hosting section when you need serious request concurrency on your own hardware or cloud VMs.
If you are new: Benchmark with your real prompt lengths—throughput marketing numbers rarely match tail latency under load.
Related: Deploy & infrastructure.
Open WebUI Chat UI for models
In plain English: Open WebUI is a popular browser-based interface for chatting with local or remote models, managing prompts, and organizing users.
On this map: Frequent pick for internal labs and homelab setups alongside Ollama.
If you are new: Put authentication in front before you expose it to the internet—default installs are for trusted networks.
Related: Local & self-hosted AI.
AnythingLLM Local / private LLM UI
In plain English: AnythingLLM bundles document ingestion, chat, and model configuration into a desktop-friendly experience for local or self-hosted models.
On this map: Local stack alternative when teams want a packaged UI over Ollama or compatible backends.
If you are new: Check RAM and GPU requirements before promising on-prem “GPT-4 quality” to stakeholders.
Related: Local & self-hosted AI.
Browsers, crawlers & the live web
Anything that fetches or drives the public web—policy and reliability matter as much as code.
Apify Scraping marketplace
In plain English: Apify hosts actors (containers) that scrape, crawl, or automate sites with scheduling, proxies, and datasets.
On this map: Social and hard-target web row when you need maintained scrapers instead of one-off scripts.
If you are new: Pick actors with clear maintenance stories; broken selectors break agents silently.
Related: Web automation.
Bright Data Proxies & datasets
In plain English: Bright Data provides residential proxies, datasets, and scraping infrastructure for difficult targets at enterprise scale.
On this map: Paired with Apify when compliance-reviewed large-scale web access is required.
If you are new: Involve legal early—proxy usage without policy alignment is career-limiting.
Related: Web automation.
Playwright Browser automation
In plain English: Playwright automates Chromium, Firefox, and WebKit with a modern API, auto-waits, tracing, and strong test tooling.
On this map: Core technology under many AI browser agents and the Playwright MCP integration.
If you are new: Learn locators and tracing before you let an LLM free-click arbitrary XPaths.
Related: Web automation.
Playwright MCP MCP + Playwright
In plain English: Playwright MCP exposes browser actions as MCP tools so models can navigate pages through a standard tool protocol.
On this map: Bridge between “agent frameworks” and “real browser” in this stack.
If you are new: Always run untrusted browsing in isolated environments with secret redaction.
Related: Web automation.
Selenium Browser automation (classic)
In plain English: Selenium is the classic browser automation stack; still common in enterprises with large existing suites.
On this map: Mentioned as legacy-compatible alternative thinking—not the default for new greenfield agent stacks.
If you are new: Prefer Playwright for new projects unless policy mandates Selenium.
Related: Web automation.
Browserbase Cloud browsers
In plain English: Browserbase runs headless browsers remotely with APIs aimed at AI agents, recordings, and scaling sessions.
On this map: Hosted browser row for agents that should not run Chrome on your laptop in production.
If you are new: Treat sessions like cattle—restart cleanly, rotate fingerprints/profiles responsibly, and audit recordings.
Related: Web automation.
Director No-code web automation
In plain English: Director is a Browserbase product that turns natural-language tasks into repeatable browser automations and exportable Stagehand code.
On this map: On-ramp for operators; engineers can take exported scripts into repos.
If you are new: Verify the latest positioning at browserbase.com/director or director.ai. Start with internal admin sites before customer portals—credentials and 2FA need explicit design.
Related: Web automation.
Stagehand MCP Browser agent tools
In plain English: Stagehand is Browserbase’s open-source, prompting-oriented browser automation framework; Stagehand MCP exposes it to MCP-compatible clients.
On this map: Connects cloud browsers and agent runtimes in the web automation section.
If you are new: Read Browserbase docs for model routing—keys and billing often flow through their gateway in quickstarts.
Related: Web automation.
APIs, UI & customer-facing product
How users sign in, pay, and click—keep this layer boring so agents can be interesting.
FastAPI Python web framework
In plain English: FastAPI builds high-performance APIs in Python with automatic OpenAPI docs and Pydantic validation—great for agent backends.
On this map: Primary API framework in the full-stack map for Python-first teams.
If you are new: Use dependency injection for DB sessions and auth—avoid giant global state.
Related: Full-stack application.
Flask Python microframework
In plain English: Flask is a minimal Python web framework—you add extensions for ORMs, auth, and async as needed.
On this map: Alternative when teams prefer explicit simplicity over FastAPI’s async defaults.
If you are new: Be disciplined about project structure; Flask won’t stop you from spaghetti.
Related: Full-stack application.
Express Node.js HTTP framework
In plain English: Express is the de facto minimal HTTP framework for Node.js APIs and server-rendered hybrids.
On this map: TypeScript end-to-end teams often pair Express (or similar) with React frontends.
If you are new: Centralize error middleware and avoid callback pyramids—use async/await consistently.
Related: Full-stack application.
React UI library
In plain English: React builds user interfaces from components with a virtual DOM and a huge ecosystem for state, routing, and design systems.
On this map: Primary SPA choice with Vite in this stack’s product layer.
If you are new: Learn hooks and keys in lists before you let agents generate huge component trees unchecked.
Related: Full-stack application.
Vite Frontend build tool
In plain English: Vite is a fast dev server and bundler for modern JavaScript/TypeScript, especially pleasant with React and Vue.
On this map: Default dev/build pipeline next to React in the map.
If you are new: Understand `import.meta.env` vs Node `process.env`—misconfigurations leak between client and server bundles.
Related: Full-stack application.
Next.js React framework
In plain English: Next.js adds file-based routing, server components, API routes, and deployment optimizations on top of React.
On this map: Alternative when you want SSR/SSG and Vercel-style workflows integrated with React.
If you are new: Decide clearly what runs on server vs client—secrets must never ship to browser bundles.
Related: Full-stack application.
Vue UI framework
In plain English: Vue is a progressive JavaScript framework for SPAs with approachable templates and an official ecosystem for routing and state.
On this map: Alternative UI stack when team skills or legacy code favor Vue over React.
If you are new: Composition API is the modern default—avoid mixing old Options API patterns without reason.
Related: Full-stack application.
Streamlit Python UI
In plain English: Streamlit turns Python scripts into interactive web apps—great dashboards and internal tools with almost no frontend code.
On this map: Early UX and internal dogfood before you invest in a full React product shell.
If you are new: Not a replacement for fine-tuned public marketing sites—use it where speed beats pixel polish.
Related: Full-stack application.
shadcn/ui Copy-paste components
In plain English: shadcn/ui is not an npm dependency you blindly upgrade—it is a set of Radix-based components you copy into your repo and own.
On this map: Design system speedrun for React + Tailwind teams.
If you are new: Run accessibility checks anyway; copied components still need correct labels and focus order.
Related: Full-stack application.
Tailwind CSS Utility-first CSS
In plain English: Tailwind encodes design tokens as small utility classes so you style in JSX/HTML quickly with consistent spacing and colors.
On this map: Default styling approach paired with React and shadcn patterns.
If you are new: Configure purge/content paths so production CSS stays small.
Related: Full-stack application.
Clerk Auth for SaaS
In plain English: Clerk provides hosted sign-in, session, and user management components with strong DX for React/Next apps.
On this map: Product auth alternative when you do not self-host Supabase Auth patterns exclusively.
If you are new: Map Clerk organizations to your tenancy model early for B2B.
Related: Full-stack application.
Okta Enterprise IdP
In plain English: Okta is a major identity provider for workforce and customer SSO, MFA, and lifecycle management.
On this map: Representative enterprise IdP chip separate from SAML as a protocol.
If you are new: Test SAML/OIDC metadata rotation and certificate expiry alerts—outages here lock everyone out.
Related: Full-stack application.
Enterprise IdP Identity provider (concept)
In plain English: An enterprise identity provider (IdP) is the system of record for users, groups, MFA, and SSO—examples include Okta, Microsoft Entra ID, Ping, and others your IT team already runs.
On this map: Called out in the product layer when Supabase Auth alone is not enough for corporate SSO, SCIM, or audit policies.
If you are new: Ask IT for OIDC vs SAML, test user groups, and plan a break-glass admin before you wire production traffic.
Related: Full-stack application.
Active Directory Directory services
In plain English: Active Directory (and cloud evolution via Microsoft Entra ID) stores users, groups, and policies for corporate networks.
On this map: Illustrative alongside SAML for “big company SSO” context—not the only SAML directory.
If you are new: Speak the customer’s language: AD on-prem vs Entra cloud vs hybrid matters for integration timelines.
Related: Full-stack application.
Stripe Payments
In plain English: Stripe processes cards, subscriptions, and invoices with developer-friendly APIs and hosted components.
On this map: Default payments layer for SaaS in this map.
If you are new: Use webhooks with idempotency keys—agents and retries will duplicate events.
Related: Full-stack application.
Lemon Squeezy Merchant of record
In plain English: Lemon Squeezy handles payments plus tax/VAT complexity as merchant of record for many digital products.
On this map: Alternative when small teams want less sales-tax operational burden than raw Stripe.
If you are new: Read payout schedules and fee tables—MoR convenience trades margin.
Related: Full-stack application.
Paddle Billing platform
In plain English: Paddle also offers merchant-of-record style billing for SaaS with localization features.
On this map: Second alternative in the payments row for international SaaS.
If you are new: Compare contract minimums vs Stripe for your revenue stage.
Related: Full-stack application.
PostHog Product analytics
In plain English: PostHog is open-source product analytics with event capture, funnels, feature flags, and session replay options depending on configuration.
On this map: Representative analytics layer for understanding how users engage with AI features.
If you are new: Define a small event taxonomy early; “log everything” creates noisy, unusable graphs.
Related: Full-stack application.
Sentry Error monitoring
In plain English: Sentry captures exceptions, stack traces, and release metadata across web, mobile, and backend services with alerting rules.
On this map: Default error tracking for APIs and frontends in this stack’s product layer.
If you are new: Tag errors with `user_id` hashes, not raw PII, and scrub agent prompts if they may contain secrets.
Related: Full-stack application.
Bolt.new AI app builder
In plain English: Bolt.new is a StackBlitz-era style in-browser builder that generates full-stack apps from prompts for rapid prototyping.
On this map: Product exploration tool in the map—not always the long-term source of truth for production repos.
If you are new: Export to Git early; browser-only sandboxes may not match your production constraints.
Related: Full-stack application.
bolt.diy Self-hosted Bolt
In plain English: bolt.diy is a community self-hosted variant/theme around the Bolt-style experience for teams that want local control.
On this map: Alternative when policy forbids cloud codegen sandboxes.
If you are new: Treat community forks like any OSS—audit updates and supply chain.
Related: Full-stack application.
Lovable AI product builder
In plain English: Lovable (formerly GPT Engineer–class products in the same space) helps generate UI and code from natural language for fast starts.
On this map: Exploration alternative to Bolt for product sketches.
If you are new: Own your design tokens and accessibility checklist—generated UI still needs human review.
Related: Full-stack application.
Shipping, CI & cloud
Runtimes, GPUs, and the platforms that execute what you built.
Docker Containers
In plain English: Docker packages your app, its dependencies, and a filesystem snapshot into an image you can run the same way on a laptop and in the cloud.
On this map: Default packaging story for APIs, workers, and agent services in this reference.
If you are new: Learn `Dockerfile`, multi-stage builds, and how to pass secrets via orchestrator env—not baked into images.
Related: Deploy & infrastructure.
Podman Containers (daemonless)
In plain English: Podman runs OCI containers similarly to Docker but with a rootless-by-default posture and a compatible CLI for many teams.
On this map: Alternative when security policy discourages a long-running Docker daemon on developer machines or servers.
If you are new: If tutorials assume `docker compose`, check Podman Compose equivalents before you commit your local dev story.
Related: Deploy & infrastructure.
GitHub Git hosting
In plain English: GitHub hosts Git repositories, issues, discussions, and (with Actions) continuous integration runners used by most open-source and many company projects.
On this map: The default place this stack assumes code, PRs, and CI logs live.
If you are new: Branch protection and required checks are non-optional once agents can commit code.
Related: Deploy & infrastructure.
GitHub Actions CI/CD
In plain English: GitHub Actions runs workflows on GitHub-hosted or self-hosted runners when events occur—push, PR, schedule, or manual dispatch.
On this map: Typical CI: lint, typecheck, tests, build images, deploy to staging.
If you are new: Cache dependencies, pin action versions, and store cloud credentials in GitHub OIDC or secrets—not in workflow YAML literals.
Related: Deploy & infrastructure.
pytest Python tests
In plain English: pytest is Python’s de facto test runner with fixtures, parametrization, and a huge plugin ecosystem.
On this map: Recommended for FastAPI, Pydantic AI, and RAG services written in Python.
If you are new: Write a few integration tests that hit your real DB in CI with containers—agents love refactoring untested glue code.
Related: Deploy & infrastructure.
Jest JavaScript tests
In plain English: Jest is a JavaScript test runner and assertion library commonly used for React and Node backends.
On this map: Paired with Next.js or Express stacks when the team is TypeScript-first.
If you are new: Use meaningful test names; future you (and agents) navigate failures by reading the spec text.
Related: Deploy & infrastructure.
CodeRabbit AI code review
In plain English: CodeRabbit-style tools post automated review comments on pull requests, summarizing risk, suggesting tests, and catching style issues.
On this map: Deployment section shorthand for “add an AI reviewer” without replacing human ownership of merges.
If you are new: Tune noise thresholds so developers trust the bot; a ignored bot teaches the wrong cultural habits.
Related: Deploy & infrastructure.
Render PaaS hosting
In plain English: Render deploys Dockerized services, static sites, cron jobs, and private networks with a Heroku-like developer experience.
On this map: Default “ship containers without k8s” story in deployment section.
If you are new: Watch cold starts on free tiers—agents hitting sleeping APIs look “flaky”.
Related: Deploy & infrastructure.
Fly.io Global VMs / containers
In plain English: Fly.io runs containers close to users on lightweight VMs with private networking and volumes for stateful services.
On this map: Alternative hosting when regional placement and anycast networking matter.
If you are new: Read their Postgres guidance carefully if you self-host databases there.
Related: Deploy & infrastructure.
Vercel Frontend / serverless
In plain English: Vercel hosts frontend frameworks (especially Next.js) with serverless functions, edge caching, and preview deployments per PR.
On this map: Natural home for Next.js in the map.
If you are new: Long-running agents belong on a worker or container platform—serverless timeouts are real.
Related: Deploy & infrastructure.
Netlify JAMstack hosting
In plain English: Netlify hosts static sites and serverless functions with Git-based deploys and edge integrations.
On this map: Alternative static/SSR edge host when teams already standardized there.
If you are new: Understand function limits vs your AI proxy needs.
Related: Deploy & infrastructure.
DigitalOcean Cloud VMs
In plain English: DigitalOcean provides straightforward VMs, Kubernetes, managed databases, and app platforms with approachable pricing pages.
On this map: General-purpose hyperscaler alternative for small teams.
If you are new: Use managed DB backups and floating IPs for anything customer-facing.
Related: Deploy & infrastructure.
Hetzner EU cloud / bare metal
In plain English: Hetzner offers cost-effective servers and cloud VMs, popular in EU for price-sensitive workloads.
On this map: Budget hosting alternative when latency to EU users is acceptable globally.
If you are new: Read support SLAs—low cost sometimes means more self-support.
Related: Deploy & infrastructure.
Hostinger Web hosting
In plain English: Hostinger provides shared hosting, VPS, and managed WordPress—consumer-leaning but sometimes used for simple sites.
On this map: Listed as a broad-market host alternative—not specialized for GPU inference.
If you are new: Match workload to product—do not run heavy GPU jobs on small shared tiers.
Related: Deploy & infrastructure.
AWS Hyperscaler
In plain English: Amazon Web Services is the largest cloud ecosystem: VPC, EC2, S3, RDS, Lambda, SageMaker, Bedrock, and hundreds more services.
On this map: Hyperscaler track when compliance or existing enterprise agreements mandate AWS.
If you are new: Enable org-level guardrails and cost anomaly alerts on day one—agents can spin expensive resources quickly.
Related: Deploy & infrastructure.
GCP (Google Cloud) Hyperscaler
In plain English: Google Cloud Platform offers compute, storage, BigQuery, Vertex AI, and tight integration with Google’s ML stacks.
On this map: Alternative hyperscaler when teams already on BigQuery/Gemini enterprise paths.
If you are new: Learn IAM binding basics—overly broad service accounts are a common breach path.
Related: Deploy & infrastructure.
Lambda Labs GPU cloud
In plain English: Lambda Labs rents GPU servers aimed at ML training and inference workloads with straightforward GPU SKUs.
On this map: GPU section alternative for teams who want dedicated machines.
If you are new: Snapshot disk images and test CUDA/driver compatibility for your model server.
Related: Deploy & infrastructure.
RunPod GPU cloud / serverless
In plain English: RunPod provides on-demand GPUs and serverless endpoints for inference and training experiments.
On this map: Common pick for bursty inference and fine-tuning experiments.
If you are new: Cold start and queueing behavior matter for user-facing agents—measure end-to-end.
Related: Deploy & infrastructure.
TensorDock GPU marketplace
In plain English: TensorDock is a marketplace-style provider for renting GPU capacity from various suppliers.
On this map: Budget-flexible GPU alternative—verify operational maturity for production SLAs.
If you are new: Read network egress and disk performance—training jobs bottleneck unexpectedly.
Related: Deploy & infrastructure.
Local, edge & self-host networking
TLS termination and home-lab friendly stacks.
Caddy Web server / reverse proxy
In plain English: Caddy is a web server with automatic HTTPS via Let’s Encrypt and simple config files—great for small deployments.
On this map: Local/self-host stack termination alongside Traefik and NGINX.
If you are new: Keep DNS under control—ACME failures are silent until users see certificate errors.
Related: Local & self-hosted AI.
Traefik Edge router
In plain English: Traefik is a dynamic reverse proxy that discovers Docker/Kubernetes routes and handles TLS termination automatically in many setups.
On this map: Popular in compose-heavy self-hosted AI stacks.
If you are new: Label routers consistently—auto-discovery magic is hard to debug when mislabeled.
Related: Local & self-hosted AI.
NGINX Web server / proxy
In plain English: NGINX serves static files, load balances HTTP, and terminates TLS in front of app servers—battle-tested everywhere.
On this map: Conservative default when teams already operate NGINX configs organization-wide.
If you are new: Version-control your configs; one-line proxy_pass mistakes become outages.
Related: Local & self-hosted AI.
Developer workflow & third-party accounts
How software gets written and which OAuth demos show up in agent tutorials.
n8n Workflow automation
In plain English: n8n is a node-based workflow tool for connecting APIs, transforms, schedules, and human approvals—like “Zapier you can self-host”.
On this map: Used here as a fast way to prototype agent-adjacent automation and integrations without writing every glue script by hand.
If you are new: Start with one critical path workflow, version it, and add observability—graph sprawl becomes hard to diff in Git.
Related: Core infrastructure.
Claude Code AI coding agent
In plain English: Claude Code is Anthropic’s agentic coding experience that edits files, runs commands, and reasons across a repo inside guardrails you configure.
On this map: Appears as a primary “AI-native development” companion alongside your IDE and review tools.
If you are new: Treat it like a very fast junior: require tests, small PRs, and human review on security-sensitive files.
Related: Core infrastructure.
Claude Skills Packaged agent capabilities
In plain English: Claude Skills are reusable, documented capability packs (prompts, tools, and conventions) that teach Claude how to perform a recurring job consistently inside Claude products.
On this map: Indexed here next to Claude Code as part of the same vendor ecosystem for structured agent behavior beyond one-off chats.
If you are new: Version skills like code: review changes, test on sample inputs, and avoid embedding secrets inside skill text files.
Related: Core infrastructure.
Archon Task + knowledge (IDE)
In plain English: Archon (in this document’s sense) refers to a structured layer beside the IDE that tracks tasks, specs, and retrieved context for long sessions.
On this map: Paired with Claude Code to reduce “lost in chat” problems when agents work across many files.
If you are new: If you cannot find where decisions live, agents will not either—centralize task notes and links to specs.
Related: Core infrastructure.
Cursor AI IDE
In plain English: Cursor is a code editor built around AI assistance—inline edits, chat, and repo-aware prompts with tight Git integration.
On this map: Representative of the “AI-first editor” category in the stack overview.
If you are new: Keep `.cursorignore` and secrets hygiene tight; the model only knows what the editor can read.
Related: Core infrastructure.
Codex Coding models / tools
In plain English: Codex historically referred to OpenAI’s code-capable models; in conversation today people also mean OpenAI’s coding agent products and APIs in the same family.
On this map: Listed as an alternative coding-assistant track alongside Claude-oriented tooling.
If you are new: Read the current product name and pricing page—names shift faster than architecture articles.
Related: Core infrastructure.
Gmail Email API
In plain English: Google’s Gmail APIs let apps send or read mail with OAuth—common in “agent inbox” demos.
On this map: Third-party accounts bundle—never use static passwords for agents.
If you are new: Use incremental scopes and least privilege; reading mail is legally sensitive.
Related: Tool index (by area).
Slack Chat platform API
In plain English: Slack APIs power bots, slash commands, and interactive messages inside workspaces.
On this map: Third-party accounts example for notifications and human approvals.
If you are new: Verify workspace vs enterprise grid differences before you promise features.
Related: Tool index (by area).
Reddit Social API
In plain English: Reddit’s API allows scripted access to posts and comments subject to pricing and terms changes.
On this map: Example “hard social target” for agents—rate limits and policy matter.
If you are new: Read current API pricing—historical free tiers have changed and broke apps overnight.
Related: Tool index (by area).
Summary
If you are new: read the layer map once, pick one layer to explore (core or agents are common), then come back here—the bullets below are easier after you have seen one vertical slice.
If you remember nothing else: stable data + clear traces + explicit auth beat clever agent topologies. Everything else on this page hangs off those three pillars.
- End-to-end AI-first defaults: data, agents, retrieval, automation, product surface, deployment, and optional local inference—each layer has a primary card and a small alternative set.
- Core: Postgres (Supabase or Neon), Redis or Valkey, Claude Code with Archon, n8n for prototypes—optimize for boring reliability and fast feedback loops.
- Agents: Pydantic AI, LangGraph when coordination is hard, Arcade for delegated auth, Langfuse for traces—ship observability before you tune prompts.
- RAG: Docling and Crawl4AI; vectors in Postgres via pgvector; Mem0 for long-term memory; Neo4j with Graphiti (Zep) for temporal graph memory; Ragas for evals; Brave or Perplexity for web search—treat pgvector as part of Postgres, not a second database.
- Web: Crawl4AI or Firecrawl, Apify or Bright Data when needed, Playwright with MCP, Browserbase for hosted sessions—match tool class to bot defenses and compliance.
- Product: FastAPI or Express, Supabase plus an enterprise IdP when required, React with Vite, shadcn and Tailwind, Streamlit for early UX, Sentry and Stripe—keep product plumbing standard so agents stay the differentiator.
- Ship: Render or hyperscalers, RunPod-class GPUs when training or batch inference needs them, Docker, GitHub Actions, pytest and Jest, CodeRabbit for review assist—containers plus CI are the contract between teams and environments.
- Local: Open WebUI, Ollama, Caddy/Traefik/NGINX, optional compose bundle—budget ops time the same way you would for any customer-facing service.