# AIMap > The portal of the AI era. Software that agents call ("For AI") and software people use or build AI with ("AI-era software"), ready-made software stacks, LLM API prices with performance data, subscription plans, fixes for real problems, learning paths and AI news across every field. We link to official sources and never host binaries. Facts we could not verify are marked as such or omitted. Languages: English (/en/) and Simplified Chinese (/zh-hans/). Other language versions only have a few entry pages. ## Machine-readable data - [API index (JSON)](https://aimap.page/api/v1/index.json): every dataset below - [Software (JSON)](https://aimap.page/api/v1/software.json): 1460 tools (693 for AI, 847 AI-era) with category, audience, licence type, pricing model, maintenance, latest version, stars and call methods; updated 2026-10-22 - Software record: https://aimap.page/api/v1/software/.json – full record incl. package registries, recent releases, alternatives, stacks, scenarios and problems - [Coding-agent setup matrix (JSON)](https://aimap.page/api/v1/agent-clients.json): 11 coding agents (Claude Code, Codex, Cursor, GitHub Copilot, Antigravity CLI…) with MCP config files, add commands, transports, rules files (AGENTS.md, CLAUDE.md…), Agent Skills folders, permission modes and sandboxes, checked against official docs 2026-10-22; plus an MCP safety checklist - [Stacks (JSON)](https://aimap.page/api/v1/stacks.json): 44 software combinations with the role of each tool - [Model API prices (JSON)](https://aimap.page/api/v1/models/pricing.json): 577 prices for 263 models (165 official pages, 79 platform pages, 333 listed on OpenRouter) in original currency plus USD, with source URL, check date, review flag, AA intelligence index, output speed and TTFT; checked 2026-10-22 - [Subscription plans (JSON)](https://aimap.page/api/v1/models/subscriptions.json): ChatGPT, Claude, Google AI, Cursor, GitHub Copilot, GLM Coding Plan - [AI news (JSON)](https://aimap.page/api/v1/news.json): 1131 stories; updated 2026-10-22 - [Need scenarios (JSON)](https://aimap.page/api/v1/scenarios.json) · [Problems & solutions (JSON)](https://aimap.page/api/v1/problems.json): 45 problems with causes, steps and references - [AI Algorithms Atlas (JSON)](https://aimap.page/api/learn/algorithms.json): 223 algorithms in 20 areas with verified original papers, prerequisites and resources, plus the v2 curriculum (stages, units, routes) - [AI learning curriculum (JSON)](https://aimap.page/api/learn.json): 55 lessons in 15 modules; lesson text at https://aimap.page/api/learn/.json - [Free AI models (JSON)](https://aimap.page/api/free-models.json): 160 free APIs and open-weight models; verified 2026-10-22 - [Benchmarks (JSON)](https://aimap.page/api/benchmarks.json): 3086 scores for 1079 models on 23 public benchmarks; updated 2026-10-22 - [Sitemap](https://aimap.page/sitemap-index.xml) ## Sections - [For AI](https://aimap.page/en/for-ai/): CLIs, MCP servers, sandboxes, browser control, gateways, retrieval, memory, skills ([中文](https://aimap.page/zh-hans/for-ai/)) · [Agent setup guide](https://aimap.page/en/for-ai/agents/) · [MCP safety checklist](https://aimap.page/en/for-ai/safety/) - [AI-era software](https://aimap.page/en/software/): coding agents, apps, meeting notes, notes, AI browsers, frameworks, local inference, training, evaluation ([中文](https://aimap.page/zh-hans/software/)) - [Stacks](https://aimap.page/en/stacks/) · [Solve a problem](https://aimap.page/en/solve/) · [Problems & fixes](https://aimap.page/en/problems/) - [Models](https://aimap.page/en/models/): [API price table & cost calculator](https://aimap.page/en/models/pricing/), [subscription plans](https://aimap.page/en/models/subscriptions/), [coding model board](https://aimap.page/en/models/coding/), [OpenRouter usage rankings](https://aimap.page/en/models/rankings/), [decision models](https://aimap.page/en/models/decision/), [VRAM calculator](https://aimap.page/en/compute/sizing/), [self-hosted compute](https://aimap.page/en/compute/), [free models](https://aimap.page/en/free-models/), [benchmarks](https://aimap.page/en/benchmarks/) - [Learn AI](https://aimap.page/en/learn/) · [External tutorials](https://aimap.page/en/learn/tutorials/) (346) - [AI news](https://aimap.page/en/news/) · [Today’s updates](https://aimap.page/en/today/) - [AI industry sites](https://aimap.page/en/sites/) · [Compliant commercial services](https://aimap.page/en/services/) - [中文站](https://aimap.page/zh-hans/) ## Software categories - [CLIs & execution basics](https://aimap.page/en/for-ai/cli/) (118): Shells, git, search, runtimes, containers and data CLIs: the low-level tools agents call most. - [MCP servers & SDKs](https://aimap.page/en/for-ai/mcp/) (100): MCP SDKs, gateways, registries and popular MCP servers. - [Sandboxes & isolation](https://aimap.page/en/for-ai/sandbox/) (49): Isolated environments where agents run code with limited file and network access. - [Browser & computer use](https://aimap.page/en/for-ai/browser/) (50): Automation that lets agents drive browsers, desktops and phones. - [Model gateways, routing & usage](https://aimap.page/en/for-ai/gateway/) (35): One endpoint for many models, with routing, rate limits, billing and usage tracking. - [Identity, secrets & agent security](https://aimap.page/en/for-ai/security/) (39): Auth, secret management, prompt-injection defence and agent security scanning. - [Document parsing & web scraping](https://aimap.page/en/for-ai/rag-docs/) (65): Turn PDFs, Office files and web pages into clean text agents can read. - [Retrieval, vector DBs & embeddings](https://aimap.page/en/for-ai/retrieval/) (57): Vector databases, RAG retrieval frameworks and embedding tools. - [Code intelligence](https://aimap.page/en/for-ai/code-intel/) (19): LSP, syntax trees and code search that help agents understand codebases. - [Memory & context](https://aimap.page/en/for-ai/memory/) (22): Long-term memory, context compression and knowledge graphs for agents. - [Skills & rules](https://aimap.page/en/for-ai/skills/) (59): Skills, rule files and spec-driven tooling you can reuse across agents. - [Protocols, specs & agent payments](https://aimap.page/en/for-ai/protocols/) (15): Agent protocols and specs such as MCP and A2A, plus agent payments. - [Coding agents & AI IDEs](https://aimap.page/en/software/category/coding-agents/) (86): Coding agents, AI IDEs and code review: Claude Code, Codex, Cursor and more. - [AI apps & chat clients](https://aimap.page/en/software/category/apps/) (76): Desktop and web AI assistants, chat front-ends and knowledge-base apps. - [AI meeting notes & transcription](https://aimap.page/en/software/category/meeting-notes/) (8): Meeting transcription, automatic summaries and action items. - [AI notes & knowledge management](https://aimap.page/en/software/category/notes/) (23): Notes, personal knowledge bases and document Q&A with AI built in. - [AI browsers](https://aimap.page/en/software/category/ai-browser/) (8): Browsers with a built-in assistant or agent that summarise pages and act on the web for you. - [AI writing & presentations](https://aimap.page/en/software/category/writing/) (23): AI tools for writing, translation, slides and spreadsheets. - [AI image & video](https://aimap.page/en/software/category/image-video/) (83): Image generation, video generation and editing tools. - [AI office & productivity](https://aimap.page/en/software/category/office/) (32): AI tools for spreadsheets, documents, email, calendars, CRM and everyday office work. - [AI app & site builders](https://aimap.page/en/software/category/app-builder/) (13): Tools that generate websites, apps and prototypes from natural language. - [AI search & research](https://aimap.page/en/software/category/research/) (21): AI search engines, deep research and intelligence tools. - [AI finance & quant](https://aimap.page/en/software/category/finance/) (10): AI tools for investment research, quantitative trading and financial analysis. - [Agent frameworks & SDKs](https://aimap.page/en/software/category/frameworks/) (94): Frameworks and SDKs for building agents and LLM apps. - [Local inference & serving](https://aimap.page/en/software/category/local-inference/) (83): Run models on your machine or servers: Ollama, llama.cpp, vLLM and more. - [Open-weight models](https://aimap.page/en/software/category/models/) (53): Official repositories of open-weight models; free APIs and benchmarks are in the Models section. - [Training & fine-tuning](https://aimap.page/en/software/category/training/) (54): Pre-training, fine-tuning, RL and distributed training tools. - [Evaluation, red-teaming & guardrails](https://aimap.page/en/software/category/eval/) (36): Evaluation, regression tests, red-teaming and guardrails for models and agents. - [Observability & tracing](https://aimap.page/en/software/category/observability/) (37): Log LLM calls, traces, cost and quality. - [Workflow & agent platforms](https://aimap.page/en/software/category/workflow/) (39): Low-code workflows, enterprise agent platforms and orchestration. - [Speech recognition & synthesis](https://aimap.page/en/software/category/speech/) (53): Speech-to-text, text-to-speech and real-time voice tooling. ## Stacks - [Creator / self-media](https://aimap.page/en/stacks/creator-self-media/): Topics, copy, covers, short video and scheduling. - [Legal document workflow](https://aimap.page/en/stacks/legal-documents/): Summarize, compare and search contracts/case files (human review required). - [Product manager workflow](https://aimap.page/en/stacks/product-manager/): Research, PRDs, prototypes, roadmaps and eng collaboration. - [Small team collaboration](https://aimap.page/en/stacks/small-team-collab/): Connect docs, tasks, meeting notes and automation. - [Meeting notes automation](https://aimap.page/en/stacks/meeting-notes/): Auto-transcribe meetings, summarize and push action items. - [Vibe-coding app builders](https://aimap.page/en/stacks/vibe-coding-apps/): Ship deployable apps from natural language. - [Designer workflow](https://aimap.page/en/stacks/designer-stack/): From concept to hi-fi: generate, design systems, hand off to coding agents. - [AI video production](https://aimap.page/en/stacks/ai-video-production/): From script to finished video: generate, edit, caption and voice. - [AI music generation](https://aimap.page/en/stacks/music-generation/): Generate usable songs/scores and separate stems. - [Image & design generation](https://aimap.page/en/stacks/image-design-gen/): Generate and refine product shots, marketing visuals and 3D assets. - [Podcast production](https://aimap.page/en/stacks/podcast-production/): Record, transcribe, edit and publish end-to-end. - [AI customer support](https://aimap.page/en/stacks/ai-customer-support/): Answer FAQs with knowledge + agents, escalate hard tickets to humans. - [Low-code AI workflows](https://aimap.page/en/stacks/low-code-ai-workflow/): Build AI apps and automations by drag and drop, self-hostable, for teams that do not want to code from scratch. - [Student learning stack](https://aimap.page/en/stacks/student-learning/): Explain, practice, note-taking and exam review in one line. - [Voice agent stack](https://aimap.page/en/stacks/voice-agent/): Low-latency speech I/O plus an actionable agent. - [AI coding workflow](https://aimap.page/en/stacks/ai-coding-workflow/): Daily loop of reading, editing, PRs and review with coding agents. - [Enterprise knowledge RAG](https://aimap.page/en/stacks/enterprise-rag/): Governed RAG over company docs, tickets and wikis with permissions and observability. - [Model gateway & cost control](https://aimap.page/en/stacks/model-gateway-and-cost-control/): One endpoint for every model: budgets and rate limits per team, automatic fallback, and clear spend per person and project. - [Multi-model gateway](https://aimap.page/en/stacks/multi-model-gateway/): One API to switch models, fail over and control cost. - [Low-cost indie developer](https://aimap.page/en/stacks/low-cost-indie-dev/): Ship products with free models and open-source tools as much as possible. - [Paper reading & research](https://aimap.page/en/stacks/paper-reading-research/): Read papers, survey literature, run experiments and take notes. - [Personal knowledge base](https://aimap.page/en/stacks/personal-knowledge-base/): Capture notes, web pages and PDFs into a searchable second brain that AI can answer from. - [Sales & CRM agents](https://aimap.page/en/stacks/sales-crm-agents/): Agents help with leads, email and CRM hygiene. - [Agent skills system](https://aimap.page/en/stacks/agent-skills-pack/): Reusable skills to raise coding-agent output quality. - [Browser automation agent](https://aimap.page/en/stacks/browser-automation-agent/): Let agents use a real browser for logged-in tasks, scraping and forms. - [Self-hosted personal agent](https://aimap.page/en/stacks/self-hosted-agent/): Run a 24/7 personal assistant on your own machine with controlled permissions. - [Coding agent workbench](https://aimap.page/en/stacks/coding-agent-workbench/): A terminal coding agent with up-to-date docs lookup, semantic code navigation, a shared rules file and usage tracking. - [Quant research & trading agents](https://aimap.page/en/stacks/quant-research/): Multi-agent research, screening and backtests (not investment advice). - [Local private LLM](https://aimap.page/en/stacks/local-private-llm/): Keep data on-device while running chat, APIs and simple agents. - [Deep research agent](https://aimap.page/en/stacks/deep-research-agent/): Build your own web research assistant: self-hosted search, page fetching, Markdown conversion, and an agent framework that writes the report. - [Enterprise RAG knowledge base](https://aimap.page/en/stacks/enterprise-rag-knowledge-base/): Team-scale document Q&A: deep document parsing, a scalable vector database, one model gateway, plus tracing and quality evaluation. - [Fine-tune open-weight models](https://aimap.page/en/stacks/fine-tune-open-models/): Prepare data, fine-tune on modest GPUs, track experiments, then serve the result as an API. - [Run LLMs on your own computer](https://aimap.page/en/stacks/run-llms-on-your-computer/): From one-click installs to command-line tuning: download open-weight models, run them locally and expose an OpenAI-compatible API to other tools. - [OpenClaw-style assistant ecosystem](https://aimap.page/en/stacks/openclaw-ecosystem/): Center on an OpenClaw-style runtime; add desktop, sandbox, memory and channels. - [Safe agent execution environment](https://aimap.page/en/stacks/safe-agent-sandbox/): Run agent-generated code in isolation, keep secrets out of the context window, and scan for leaks before committing. - [LLM app monitoring & evaluation](https://aimap.page/en/stacks/llm-observability-and-eval/): Gate quality with regression tests before release, then record traces, cost and latency in production to catch silent degradation. - [MCP server starter kit](https://aimap.page/en/stacks/mcp-server-starter-kit/): Write your own MCP server with an SDK, debug it with the Inspector, and add the most-used official MCP servers. - [Security & red-team agents](https://aimap.page/en/stacks/security-redteam-agents/): Authorized vuln discovery, skill audits and agent defenses. - [Air-gapped / intranet](https://aimap.page/en/stacks/airgapped-intranet/): Chat, knowledge base and coding help with no internet egress. - [Local private knowledge base](https://aimap.page/en/stacks/local-private-knowledge-base/): Documents never leave your machine: a local model answers and a local vector store retrieves. Good for individuals and small teams turning PDFs and notes into a Q&A knowledge base. - [Local voice assistant](https://aimap.page/en/stacks/local-voice-assistant/): Speech recognition, a local LLM and speech synthesis all running on your machine, without cloud APIs. - [MCP toolchain](https://aimap.page/en/stacks/mcp-toolchain/): Wire MCP servers for browser, repos, docs and databases into coding agents. - [Data analytics / GenBI](https://aimap.page/en/stacks/data-analytics-genbi/): Natural-language querying, charts and reports. - [Observability & evals](https://aimap.page/en/stacks/observability-evals/): Trace agents, cost and failures; run regression evals. ## Need scenarios - [Control AI costs and usage limits](https://aimap.page/en/solve/control-ai-cost/): See what Claude Code, Codex and API calls actually use, set budgets and rate limits for a team, and route requests to cheaper models when it makes sense. - [Let agents run safely](https://aimap.page/en/solve/safe-agent-execution/): Give agents an isolated place to run, limit which files and networks they can touch, be able to undo mistakes, and defend against prompt injection and leaked secrets. - [Connect tools to agents (MCP, CLI, auth)](https://aimap.page/en/solve/connect-tools-to-agents/): Pick the smallest set of MCP servers and CLIs that does the job, set up authentication, and fix connection failures or tool lists that flood the context window. - [Share rules and skills across agents](https://aimap.page/en/solve/share-rules-and-skills/): Reuse one AGENTS.md and one set of skills across Claude Code, Codex, Cursor and Gemini CLI instead of maintaining copies. - [Switch models: your own key, Chinese or local models](https://aimap.page/en/solve/switch-models/): Point coding agents and apps at other vendors, Chinese models or local models, and understand protocol compatibility and differences in tool-calling quality. - [Run models on your own machine](https://aimap.page/en/solve/run-models-locally/): Estimate what your VRAM or RAM can run, pick an inference runtime, and configure context length and chat templates. - [Use AI compliantly in mainland China](https://aimap.page/en/solve/use-ai-compliantly-in-china/): Compliant ways to use AI in mainland China: filed domestic platforms, self-hosted open-weight models, and grey-market practices to avoid. Access from China has not been tested in this release. - [Build RAG and process documents](https://aimap.page/en/solve/rag-and-documents/): Turn PDFs and web pages into clean text, choose vector stores and rerankers, debug poor retrieval, and give agents long-term memory. - [Evaluate and monitor AI quality](https://aimap.page/en/solve/evaluate-and-monitor/): Build regression tests for prompts and agents, record traces, catch silent model degradation, and tell vendor-reported scores from independent ones. - [Find free AI resources and credits](https://aimap.page/en/solve/free-ai-resources/): Free APIs, open-weight models, limited-time offers and new-user credits, with conditions and verification dates; for student perks such as the GitHub Student Pack and free Copilot see the Students scenario. - [Choose tools and avoid pitfalls](https://aimap.page/en/solve/choose-and-avoid-pitfalls/): Check whether a project is still maintained, whether its licence allows commercial use, whether it was renamed or acquired, where to migrate when it stops, and how to choose frameworks and platforms. - [Learn AI (roadmaps, tutorials)](https://aimap.page/en/solve/learn-ai/): Learning paths from complete beginner to developer and researcher, plus curated free external tutorials and the software you need along the way. - [Everyday work: writing, translation and slides](https://aimap.page/en/solve/everyday-work-writing/): Pick one main AI assistant for email, reports, translation, summaries and slides; understand free vs ~$20 tiers and options available in China. - [Code with AI: choose tools, keep quality](https://aimap.page/en/solve/ai-coding/): Choose between Cursor, Claude Code, Codex, Copilot and others, set up rules files and tests, and keep AI-written code reviewable and reversible. - [Build apps and sites without coding](https://aimap.page/en/solve/build-apps-without-code/): Ship a real product with natural-language builders such as Lovable, v0, Bolt and Replit, and add sign-in, database permissions and security checks before launch. - [Personal knowledge base: AI that answers from my files](https://aimap.page/en/solve/personal-knowledge/): Collect notes, PDFs and web pages in one place and have AI answer only from them with citations, either in the cloud (NotebookLM etc.) or fully local. - [Private LLMs and knowledge bases for the enterprise](https://aimap.page/en/solve/enterprise-private-ai/): Deploy chat, knowledge-base and agent platforms on your intranet or private cloud: choose models and inference engines, size hardware, set permissions and audit, and check compliance in China. - [AI customer support and sales assistants](https://aimap.page/en/solve/customer-support-sales/): Answer common questions with a knowledge-base bot and hand complex ones to humans; let AI draft follow-ups and tidy the CRM while people approve what goes out. - [Meeting notes and team workflow automation](https://aimap.page/en/solve/meetings-and-team-workflow/): Transcribe meetings and turn action items into tasks automatically, use local transcription for sensitive meetings, and automate repetitive flows with n8n or Zapier. - [Research: find, read and review literature](https://aimap.page/en/solve/research-literature/): Use AI to search and read papers, write literature reviews and translate PDFs, verify that every citation exists, and disclose AI use per journal policy before submitting. - [Data analysis and reports with AI](https://aimap.page/en/solve/data-analysis/): Let AI read spreadsheets, write SQL and produce charts and reports, with read-only access, agreed metric definitions and every number traceable to a query. - [Creators: AI images and video](https://aimap.page/en/solve/create-images-video/): Choose image, video and editing tools and build a script-to-final-cut pipeline; check commercial rights and label AI-generated content where rules require it (e.g. mainland China). - [Creators: voice-over, podcasts and AI music](https://aimap.page/en/solve/audio-music-podcast/): Text-to-speech, voice cloning, podcast transcription and editing, and AI music, comparing cloud and local open-source options, plus voice consent and commercial terms. - [Students: study with AI (the right way)](https://aimap.page/en/solve/study-with-ai/): Use AI to explain, quiz you, organise notes and practise languages rather than write for you; know your school’s AI rules and the free perks available to students. ## Problems & solutions - [MCP server won’t connect: “Connection closed” / MCP error -32000](https://aimap.page/en/problems/mcp-server-not-connecting/): When a client drops an MCP server right after launching it, the launch command usually failed or the server printed logs to stdout. - [Too many MCP tools filling the context window](https://aimap.page/en/problems/mcp-too-many-tools-context/): Every connected MCP server puts the name, description and parameter schema of all its tools into the context. The more servers you connect, the less room is left for the task and the more often the model picks the wrong tool. - [Remote MCP server OAuth fails](https://aimap.page/en/problems/mcp-remote-oauth-fails/): Remote (HTTP) MCP servers usually use OAuth. Failures mostly come from a client that does not support the flow, a redirect URI mismatch, or an expired token that was not refreshed. - [How to write AGENTS.md](https://aimap.page/en/problems/how-to-write-agents-md/): AGENTS.md is a file in your repository written for coding agents, like a README for a new colleague: how to build, how to test, code style and commit rules. - [Share one set of rules across Claude Code, Codex, Cursor and Gemini CLI](https://aimap.page/en/problems/share-rules-across-agents/): Each agent reads a different rules file. Keep one main file (AGENTS.md is the usual choice) and point the other tools at it by reference, symlink or configuration. - [What Agent Skills (SKILL.md) are and how to reuse them](https://aimap.page/en/problems/agent-skills-skill-md/): A skill is a folder whose core is a SKILL.md with YAML front matter (name, description), optionally with scripts and references. The agent loads it when the description matches the task, which saves context compared with stuffing everything into a rules file. - [Use Claude Code with other models (Chinese models, your own gateway)](https://aimap.page/en/problems/claude-code-with-other-models/): Claude Code can send requests to any Anthropic-compatible endpoint set via environment variables. Many model vendors offer Anthropic-compatible APIs, and gateways such as LiteLLM or claude-code-router can translate formats. - [Use Codex CLI with local or custom model providers](https://aimap.page/en/problems/codex-cli-local-or-custom-models/): Codex CLI’s config file supports custom model providers that point at any OpenAI-compatible endpoint, including a local Ollama. - [What model size can my VRAM / RAM run?](https://aimap.page/en/problems/what-model-fits-my-vram/): Rule of thumb: weight memory ≈ parameters × bits per parameter ÷ 8, plus context (KV cache) and runtime overhead. At 4-bit quantisation that is roughly 0.5–0.7 GB per billion parameters. - [Ollama truncates long documents and the model “forgets” earlier text](https://aimap.page/en/problems/ollama-context-length-truncated/): Ollama’s default context length is much smaller than many models support (the default changes between versions). When input exceeds it, earlier content is dropped. - [llama.cpp prints garbage, mixes up roles or never calls tools](https://aimap.page/en/problems/llama-cpp-chat-template-tool-calls/): The chat template turns messages into the format the model was trained on. With the wrong template the model emits odd tokens, talks to itself or fails to call tools properly. - [vLLM fails at start-up with CUDA out of memory](https://aimap.page/en/problems/vllm-cuda-out-of-memory/): At start-up vLLM pre-allocates a share of GPU memory and reserves KV cache for the maximum context length. If the model plus context does not fit, it fails immediately. - [Stop agents from deleting files or running dangerous commands](https://aimap.page/en/problems/prevent-agent-destructive-actions/): Avoiding irreversible agent mistakes takes three layers: an isolated environment, least privilege, and a checkpoint before acting. - [Undo agent changes: git checkpoints, worktrees and reflog](https://aimap.page/en/problems/undo-agent-changes-with-git/): git is the most reliable undo button for agents: one branch or worktree per task, frequent commits, and reflog to recover committed states after a mistake. - [Keep agents from reading .env files and committing secrets](https://aimap.page/en/problems/agent-secrets-env-leak/): Any file an agent can read may end up in the model context, logs or even commits. Handle it on three fronts: expose less, detect early, rotate fast. - [Defending agents against prompt injection from web pages and documents](https://aimap.page/en/problems/prompt-injection-defense/): There is no complete fix for prompt injection today. In practice you treat external content as untrusted data and limit the damage an agent can do after reading it. - [How to check an MCP server is genuine and safe before installing](https://aimap.page/en/problems/verify-mcp-server-supply-chain/): An MCP server runs with your permissions: you are installing a program the model can call. Look-alike package names, malicious updates and instructions hidden in tool descriptions (tool poisoning) have all happened. - [How much have Claude Code / Codex used and cost?](https://aimap.page/en/problems/track-claude-code-usage-cost/): Usage windows and limits on subscription tools are opaque, and API calls are scattered. Local log analysers and a unified gateway are the two main approaches. - [Set budgets and rate limits for a team’s LLM usage](https://aimap.page/en/problems/team-llm-budget-rate-limit/): Route every model call through one gateway, issue virtual keys per person or project, and enforce budgets, rate limits and model allow-lists there. - [Which PDF/document parser to use for RAG](https://aimap.page/en/problems/pdf-parser-for-rag/): RAG quality depends heavily on parsing. Popular open-source parsers have different strengths; compare them on a sample of your own documents. We have not run a unified test yet. - [RAG retrieves the wrong passages: how to debug](https://aimap.page/en/problems/rag-retrieval-inaccurate/): First find which stage fails: parsing, chunking, retrieval or generation. Measure with a fixed question set, then improve one stage at a time. - [Giving agents memory across sessions: memory layer or rules file?](https://aimap.page/en/problems/agent-memory-across-sessions/): For coding agents a project rules file is often enough; apps for end users that need long-term memory may need a dedicated memory layer. - [Catch silent quality drops after model or prompt changes](https://aimap.page/en/problems/llm-regression-testing/): Build a fixed regression suite for prompts and agents and run it before and after every change or model switch, like unit tests. - [Self-hosted LLM observability: trace every call and agent step](https://aimap.page/en/problems/self-host-llm-observability/): Recording every model and tool call’s input, output, latency and tokens as traces is what lets you debug. Open-source options can be self-hosted so data stays on your network. - [Is this open-source AI project still maintained? How to tell](https://aimap.page/en/problems/is-this-project-still-maintained/): AI open-source projects turn over fast: stalls, archives, renames and moves to closed source are common. A few minutes checking some signals before you choose can save you from building on a dead project. - [Can I use this open-source AI tool commercially? Reading licences](https://aimap.page/en/problems/ai-tool-license-commercial-use/): “Source available” is not the same as “open-source licence”. Many popular AI tools use licences with extra conditions, such as restricting hosted SaaS use or requiring branding to stay. - [Choosing an agent framework: LangGraph, OpenAI Agents SDK, Pydantic AI, CrewAI, Mastra](https://aimap.page/en/problems/choose-an-agent-framework/): No framework is best in general; it depends on language, how much flow control you need, which models you use and how you deploy. We have not run a unified test; these are the questions to ask. - [Where to find free LLM APIs, and what the conditions are](https://aimap.page/en/problems/find-free-llm-api/): Free access comes in several forms: permanent free tiers, open-weight models (free to self-host), limited-time offers and new-user credits. Policies change fast, so check the verification date and exact conditions. - [Using LLMs compliantly in mainland China](https://aimap.page/en/problems/use-llms-compliantly-in-china/): There are two main compliant paths: platforms and models that completed the required filing and serve users in China, or open-weight models deployed in your own environment. We have not tested access from mainland China in this release. - [Where to start learning about LLMs: roadmap and tutorials](https://aimap.page/en/problems/where-to-start-learning-llms/): Choose a path by goal: to use AI, start with basics and prompting; to build apps, add RAG, tool calling, MCP and agents; for research, add maths, deep learning and Transformer internals. - [Are API relays / OpenRouter safe?](https://aimap.page/en/problems/api-relay-openrouter-safe/): Any third party that forwards your request to an upstream provider can see plaintext prompts and completions unless true end-to-end encryption exists (mainstream model APIs do not). OpenRouter is a well-documented aggregator: by default it does not keep prompts/responses long-term and offers Zero Data Retention (ZDR) routing. Opaque cheap relays often risk model substitution, inflated usage, exit scams, and silent logging. Safety depends on data sensitivity, verification, and how you pay and isolate keys—not on marketing claims. - [LiteLLM 1.107.0 was compromised: am I affected, and what to do](https://aimap.page/en/problems/litellm-1-107-0-supply-chain-compromise/): On 2026-10-21 LiteLLM’s release pipeline was compromised: all seven litellm==1.107.0 wheels on PyPI and the Docker images v1.107.0 / latest / main-latest / main-stable shipped a credential stealer and a remote-code loader. Per the official post, the PyPI package was live 11:39–13:23 UTC and the Docker images 11:46–14:20 UTC; the v1.107.0 source tag on GitHub is clean, earlier versions are safe, and the artifacts have been removed. Treat any environment that installed it unpinned or pulled those images in that window as compromised. - [Cursor vs Claude Code vs Codex vs Copilot: which to choose](https://aimap.page/en/problems/choose-ai-coding-tool/): All four can read and edit a whole project. The real differences are form (IDE or terminal), billing and what you already pay for. Choose the form first, then the price. - [ChatGPT, Claude or Gemini: should you pay, and for which?](https://aimap.page/en/problems/choose-ai-assistant-subscription/): For most everyday writing and Q&A the free tiers are enough. A ~$20 plan is worth it only if you keep hitting limits or need stronger models or features such as deep research, and usually one plan is enough. - [Get AI to answer only from your own files (NotebookLM)](https://aimap.page/en/problems/notebooklm-answers-from-my-sources/): NotebookLM answers only from the sources you add to a notebook and marks where each answer comes from, which suits reading notes, course material and papers. - [Build a private ChatGPT on your own computer (Ollama + Open WebUI)](https://aimap.page/en/problems/private-chatgpt-with-ollama-open-webui/): Run open-weight models locally with Ollama and get a ChatGPT-like web interface with Open WebUI; chats and files never leave your machine. - [Self-host Dify on company servers (Docker Compose)](https://aimap.page/en/problems/deploy-dify-self-hosted/): Dify can be deployed on your own servers with Docker Compose and connected to private models or cloud APIs to build knowledge-base Q&A and internal AI apps. - [Employees paste company data into AI: what to do](https://aimap.page/en/problems/stop-company-data-leaking-to-ai/): Blanket bans rarely work; people switch to personal accounts. It works better to provide an approved route (enterprise plan or private deployment) plus data classification and auditing. - [Transcribe meeting recordings locally (Whisper / faster-whisper)](https://aimap.page/en/problems/transcribe-meetings-locally/): When sensitive meetings must not be uploaded, transcribe them on your own computer with Whisper-family models, then summarise with a local or trusted model. - [Generate images locally with ComfyUI](https://aimap.page/en/problems/comfyui-generate-images-locally/): ComfyUI is a node-based local image generator: unlimited, reproducible and batch-friendly. Beginners can start with simpler Fooocus or InvokeAI. - [Labelling AI-generated images and video on Chinese platforms](https://aimap.page/en/problems/label-ai-generated-content-china/): China’s Measures for Labelling AI-Generated Synthetic Content took effect on 1 September 2025: users who publish AI-generated content must declare it and use the platform’s labelling tools, and must not remove or alter labels. - [How to disclose AI use in a paper](https://aimap.page/en/problems/disclose-ai-use-in-papers/): Major journals and ICMJE agree: AI cannot be an author; describe how AI assisted writing or analysis when you submit; authors are responsible for everything. Exact placement and wording follow the target journal’s policy. - [AI-generated references that don’t exist](https://aimap.page/en/problems/ai-fake-citations/): LLMs can produce perfectly formatted references that do not exist, or mix real authors and journals with wrong titles. Verify every AI-provided citation. - [Security checks before launching a vibe-coded app](https://aimap.page/en/problems/secure-vibe-coded-app/): The most common problems in AI-generated apps are databases without access control and API keys in front-end code. Before launch, at least enable row-level security, move secrets server-side and run a security scan. - [Free AI tools for students](https://aimap.page/en/problems/free-ai-for-students/): Students can use most AI without paying: free tiers of major assistants, NotebookLM and local open models; for coding, GitHub student verification unlocks Copilot for free. ## Learning routes - [Everyday Users](https://aimap.page/en/learn/track/t-everyone/): 7 units, about 40 hours - [Application Developers](https://aimap.page/en/learn/track/t-builder/): 16 units, about 126 hours - [Algorithm Researchers](https://aimap.page/en/learn/track/t-researcher/): 24 units, about 257 hours - [Product Managers & Leaders](https://aimap.page/en/learn/track/t-leader/): 12 units, about 84 hours - [Domain Scientists](https://aimap.page/en/learn/track/t-scientist/): 15 units, about 143 hours ## AI Algorithms Atlas - [Atlas overview](https://aimap.page/en/learn/algorithms/): 223 algorithms, each with its original paper - [Classical Machine Learning](https://aimap.page/en/learn/algorithms/c/classic-ml/): Statistical learning methods that predate deep learning and still dominate tabular and small-data problems. - [Deep Learning Foundations](https://aimap.page/en/learn/algorithms/c/dl-foundations/): How neural nets are trained: backprop, optimizers, normalization, activations and classic architectures. - [Transformers & Attention](https://aimap.page/en/learn/algorithms/c/transformer/): The backbone of LLMs: attention, positional encodings, tokenization and variants like FlashAttention, GQA/MLA and long context. - [Mixture of Experts](https://aimap.page/en/learn/algorithms/c/moe/): Sparse models that activate only some parameters, growing capacity without proportional compute. - [New Architectures: SSM & Linear Attention](https://aimap.page/en/learn/algorithms/c/new-arch/): Post-Transformer directions: Mamba, RWKV, linear attention, hybrids and diffusion language models. - [Pretraining, Scaling & Distributed Training](https://aimap.page/en/learn/algorithms/c/pretraining/): Scaling laws, hyperparameter transfer, mixed precision and parallelism — how frontier models get trained. - [Alignment & Preference Optimization](https://aimap.page/en/learn/algorithms/c/alignment/): Making models helpful and harmless: RLHF, DPO, Constitutional AI, GRPO and RL with verifiable rewards. - [Reasoning & Test-Time Compute](https://aimap.page/en/learn/algorithms/c/reasoning/): Chain of thought, self-consistency, process rewards and test-time scaling behind o1/R1-style reasoners. - [Fine-tuning & PEFT](https://aimap.page/en/learn/algorithms/c/finetuning/): Adapting general models cheaply: LoRA, QLoRA, instruction tuning and model merging. - [Quantization, Pruning & Distillation](https://aimap.page/en/learn/algorithms/c/compression/): Making models smaller, faster and lighter so they run on one GPU, a laptop or a phone. - [Inference Acceleration & Serving](https://aimap.page/en/learn/algorithms/c/inference/): KV cache, speculative decoding, PagedAttention, continuous batching — making LLM serving fast and cheap. - [Diffusion, Flow Matching & Generative Models](https://aimap.page/en/learn/algorithms/c/generative/): VAEs, GANs, diffusion, flow matching and DiT — the algorithms behind image, video and audio generation. - [Multimodal & Vision](https://aimap.page/en/learn/algorithms/c/multimodal/): ViT, CLIP, VLMs, speech, segmentation and 3D reconstruction — letting AI see and hear. - [RAG & Vector Retrieval](https://aimap.page/en/learn/algorithms/c/retrieval/): Embeddings, vector indexes, dense retrieval, reranking and GraphRAG — connecting LLMs to knowledge. - [Agents & Tool Use](https://aimap.page/en/learn/algorithms/c/agents/): ReAct, tool calling, MCP, reflection and memory — letting models plan and act. - [Reinforcement Learning](https://aimap.page/en/learn/algorithms/c/rl/): From Q-learning to PPO, AlphaZero and MuZero — learning decisions from trial and reward. - [World Models & Self-Supervised Learning](https://aimap.page/en/learn/algorithms/c/world-models/): Simulating and predicting the world: World Models, Dreamer, JEPA, Genie, plus self-supervised learning like contrastive learning and MAE. - [Graph Neural Networks & AI for Science](https://aimap.page/en/learn/algorithms/c/graph-science/): Graph models like GCN and GAT, plus science systems like AlphaFold and AlphaGeometry. - [Interpretability](https://aimap.page/en/learn/algorithms/c/interpretability/): Opening the black box: attribution, probing, superposition, sparse autoencoders, circuit tracing and steering. - [Safety, Evaluation & Security](https://aimap.page/en/learn/algorithms/c/safety/): Adversarial examples, jailbreaks, prompt injection, red teaming, watermarking, differential privacy and scalable oversight. - [Path: Zero to Deep Learning](https://aimap.page/en/learn/algorithms/paths/p-ml-to-dl/) - [Path: Understanding an LLM End to End](https://aimap.page/en/learn/algorithms/paths/p-build-llm/) - [Path: Post-training & Reasoning Models](https://aimap.page/en/learn/algorithms/paths/p-post-training/) - [Path: AI Application Engineer](https://aimap.page/en/learn/algorithms/paths/p-ai-engineer/) - [Path: Generative Models & Frontier Research](https://aimap.page/en/learn/algorithms/paths/p-frontier/) ## AI lessons (full text) - [What Is a Large Language Model (LLM)? A Plain-Language Guide](https://aimap.page/en/learn/ai-basics/what-is-an-llm/): A plain-language explanation of LLMs: next-token prediction, parameters, training and limits. - [How Machines Learn: Loss Functions and Gradient Descent Explained](https://aimap.page/en/learn/math-ml/ml-basics/): The core loop of all modern AI training explained with one tiny example. - [Neural Networks and Backpropagation, Explained Simply](https://aimap.page/en/learn/deep-learning/neural-networks/): Neurons, layers, activations and how errors flow backwards to update millions of weights. - [Tokens and Embeddings: How LLMs Turn Text into Numbers](https://aimap.page/en/learn/llm-core/tokens-embeddings/): Tokenisation (BPE), vocabularies and the vector space where meaning lives. - [Transformers and Attention Explained: Q, K, V, Multi-Head and the Decoder Block](https://aimap.page/en/learn/llm-core/transformer-attention/): Self-attention, queries/keys/values, multi-head attention and the full decoder block. - [How LLMs Learn: Pre-training, Fine-tuning and RLHF Explained](https://aimap.page/en/learn/training/how-llms-learn/): The three-stage recipe behind ChatGPT-style assistants, and newer methods like DPO. - [What Do LLMs Learn Inside? Representations, Features and Interpretability](https://aimap.page/en/learn/interpretability/inside-llms/): Features, superposition, circuits and world models — what we know and what we don't. - [How LLMs Generate Text: Decoding, Temperature, KV Cache and Quantisation](https://aimap.page/en/learn/inference/llm-inference/): Sampling, temperature, the KV cache, batching and quantisation in one lesson. - [RAG Explained: Retrieval-Augmented Generation from Scratch](https://aimap.page/en/learn/rag/what-is-rag/): Chunking, embeddings, vector search, re-ranking and grounded answers with citations. - [How AI Agents Work: The Agent Loop, Tools, Planning and Memory](https://aimap.page/en/learn/agents/how-agents-work/): Model + tools + loop: observe, think, act, and the patterns that make agents reliable. - [Tool Calling and MCP (Model Context Protocol) Explained](https://aimap.page/en/learn/agents/tool-calling-mcp/): How function calling works and how MCP standardises tools for every AI app. - [How to Evaluate LLMs: Benchmarks, Arenas, Agent Tests and Data Contamination](https://aimap.page/en/learn/evaluation/llm-evaluation/): What MMLU, SWE-bench and Chatbot Arena measure, and how to read leaderboards critically. - [Prompt Injection and Tool Poisoning: Why AI Agents Get Hijacked and How to Defend](https://aimap.page/en/learn/safety/prompt-injection/): Why agents that read untrusted content can be hijacked, and the defences that work. ## Optional - [About & editorial policy](https://aimap.page/en/editorial-policy/)