AI Models

Best for: Long-context coding, upgraded V3 deployments

How: Drop-in upgrade from V3. Uses Dynamic Sparse Attention for better long-context performance.

Example: Feed your entire microservice codebase and get cross-service dependency analysis.

API: api.deepseek.com OR self-host via vLLM. Same OpenAI-compatible API.

Best for: European deployments, agent workflows, long-context multilingual apps

How: Major upgrade from Large 2. MoE architecture with 41B active params. Same API, just change model ID.

Example: Build a multi-tool agent that queries DBs, calls APIs, and generates reports in 30+ languages.

API: api.mistral.ai OR self-host via vLLM. OpenAI-compatible.

Best for: Edge deployment, on-device AI, lightweight vision tasks

How: 3B fits on phones, 8B on laptops, 14B on dev GPUs. All have vision support.

Example: Run 8B on a Jetson to classify manufacturing defects from camera feeds.

API: Ollama, vLLM, Hugging Face. Also on Mistral API.

Best for: Budget alternative to flagship models, Chinese language tasks

How: OpenAI SDK with base_url='https://api.moonshot.ai/v1'. WARNING: has implicit reasoning that eats max_tokens.

Example: Use moonshot-v1-8k instead for structured JSON tasks — kimi-k2.5 wastes tokens on hidden thinking.

API: api.moonshot.ai — OpenAI-compatible

Best for: Complex multi-step coding, large codebase refactors, long-document analysis

How: Best via Claude Code CLI for coding tasks. For API: messages.create() with system prompt + tools.

Example: claude-code: point it at a repo, describe the feature, it reads/edits/tests autonomously.

API: api.anthropic.com — SDK: pip install anthropic / npm i @anthropic-ai/sdk

Best for: Production API backends, real-time chat, moderate complexity coding

How: Drop-in replacement for Opus when you need faster/cheaper. Same API, just change model ID.

Example: Use as the default model in your API gateway — upgrade to Opus only for hard problems.

API: api.anthropic.com — same SDK as Opus

Best for: High-volume processing, real-time apps, budget-conscious pipelines

How: Set thinking_budget to control reasoning cost. 0 = no thinking, 24576 = max.

Example: Summarize 1000 GitHub issues per hour for a triage dashboard at ~$1.

API: Same SDK as Gemini Pro. model='gemini-2.5-flash-preview-05-20'

Best for: Pipelines, batch processing, structured data extraction, routing

How: Use for high-volume, low-complexity tasks: classification, extraction, summarization.

Example: Process 10K support tickets per hour to classify priority and extract entities.

API: api.anthropic.com — same SDK

Best for: General-purpose API integration, multimodal apps, coding assistance

How: client.chat.completions.create(model='gpt-4.1', messages=[...]). Supports vision, tools, JSON mode.

Example: Build a PR review bot that reads diffs + screenshots and posts comments.

API: api.openai.com — SDK: pip install openai / npm i openai

Best for: Embeddings preprocessing, log parsing, lightweight generation

How: Same API as GPT-4.1. Best for high-volume, simple tasks where cost matters.

Example: Parse 50K structured logs per hour and extract error patterns.

API: api.openai.com — same SDK

Best for: Intent classification, entity extraction at massive scale

How: Use for routing, tagging, simple extraction where quality bar is lower.

Example: Route 1M incoming messages per day to the right service for $4 total.

API: api.openai.com — same SDK

Best for: Hard math, science, multi-step planning, complex debugging

How: Use reasoning_effort param: 'low'/'medium'/'high'. No system prompt — use developer message instead.

Example: Debug a distributed system deadlock by feeding it the full trace + architecture.

API: api.openai.com — same SDK, just model='o3'

Best for: Coding with reasoning, moderate-complexity math, budget reasoning

How: Cheaper reasoning model. Use when o3 is overkill but you need chain-of-thought.

Example: Generate a migration plan for a database schema change with safety checks.

API: api.openai.com — same SDK

Best for: Self-hosted production deployments, privacy-sensitive workloads

How: ollama run llama4-maverick OR deploy on vLLM with tensor parallelism. Also available hosted on Together/Groq.

Example: Deploy on 2x A100 GPUs behind your API gateway for private code review.

API: Self-host via vLLM, Ollama, or use via Together, Fireworks, Groq

Best for: Processing entire codebases, very long documents, single-GPU deployments

How: Fits on a single H100. Best open model for extreme context lengths.

Example: Feed your entire monorepo into context and ask about cross-service dependencies.

API: Same as Maverick — vLLM, Ollama, Together, Fireworks

Best for: Flexible thinking control, commercial self-hosting, multilingual

How: Supports /think and /no_think tags to toggle reasoning on/off per request. Apache 2.0 = fully commercial.

Example: Use /no_think for fast classification, /think for complex debugging — same model.

API: Self-host via vLLM/SGLang or use via Together, Fireworks. Also on Alibaba Cloud.

Best for: Local development, laptop-friendly reasoning, privacy

How: Excellent for local dev. MoE means only 3B params active — fast on consumer hardware.

Example: Run on your dev machine as a private coding assistant with reasoning.

API: ollama run qwen3:30b — fits on RTX 4090 (24GB)

Best for: UI mockups, marketing assets, diagrams with text

How: Supports text overlays, inpainting, and style control. Best text rendering of any model.

Example: Generate architecture diagrams with accurate labels from a text description.

API: api.openai.com — client.images.generate(model='gpt-image-1')

Best for: Long-document analysis, multimodal tasks, apps needing search grounding

How: client.models.generate_content(model='gemini-2.5-pro', contents=[...]). Supports grounding with Google Search.

Example: Feed a 200-page architecture doc and ask it to find security issues.

API: generativelanguage.googleapis.com — SDK: pip install google-genai

Best for: On-device/edge deployment, multimodal at small scale

How: ollama run gemma3:27b. Fits on RTX 3090/4090. Good multimodal + tool use at small size.

Example: Run on a dev server to process screenshots and generate bug reports.

API: Ollama, vLLM, Hugging Face. Also on Vertex AI.

Best for: Tasks needing real-time information, math-heavy problems

How: OpenAI SDK with base_url override. Also supports live search via tools.

Example: Monitor real-time tech news and generate summaries using live search.

API: api.x.ai — OpenAI-compatible SDK. Set base_url='https://api.x.ai/v1'

Best for: Budget reasoning tasks, math, lightweight chain-of-thought

How: Excellent cost-to-reasoning ratio. Use reasoning_effort param.

Example: Validate Terraform plans with reasoning about dependency chains for pennies.

API: api.x.ai — same as Grok 3

Best for: Self-hosted RAG, privacy-first search, zero-cost embeddings

How: Self-host for zero cost. Comparable quality to OpenAI embeddings.

Example: Run alongside pgvector on the same server — full RAG pipeline with zero API costs.

API: pip install nomic OR Ollama. Also hosted on Nomic Atlas.

Best for: Budget reasoning, self-hosted chain-of-thought, research

How: API is OpenAI-compatible. Self-host the 70B distill on 2x A100. MIT license = no restrictions.

Example: Run the 14B distill locally for debugging complex distributed system issues.

API: api.deepseek.com ($0.55/M in, $2.19/M out) OR self-host via vLLM/Ollama

Best for: Code completion, inline suggestions, editor integration

How: Supports FIM for inline completion. Integrate with any editor via LSP or Continue.dev.

Example: Deploy as your team's FIM-capable completion server behind an LSP proxy.

API: codestral.mistral.ai — dedicated code endpoint

Best for: Proven workhorse for self-hosted deployments, fine-tuning base

How: ollama run llama3.3:70b. For production: vLLM on 2x A100 or 4x A10G.

Example: Fine-tune on your internal docs for a private knowledge base chatbot.

API: Ollama, vLLM, TGI, or hosted (Together $0.60/M, Groq, Fireworks)

Best for: Cost-sensitive production APIs, coding tasks, math-heavy pipelines

How: Cheapest top-tier API. OpenAI-compatible. Self-host needs 8x A100.

Example: Replace GPT-4 in your CI pipeline for automated code review at 1/10th the cost.

API: api.deepseek.com ($0.27/M in, $1.10/M out) OR self-host

Best for: Edge deployment, STEM tasks, embedded AI in products

How: ollama run phi4. MIT license — embed in commercial products freely.

Example: Embed in a CI pipeline to validate config files and Terraform plans.

API: Ollama, Hugging Face, Azure AI

Best for: Private code completion, self-hosted Copilot replacement

How: ollama run qwen2.5-coder:32b. Plug into Continue.dev or Copilot alternatives.

Example: Set up as your team's private code completion backend — zero data leaves your infra.

API: Ollama, vLLM, or hosted on Together/Fireworks

Best for: High-quality image generation, product photography

How: API or self-host Flux.1 Schnell (open). Pro via API only.

Example: Generate product mockups for landing pages programmatically.

API: api.bfl.ml OR via Replicate, fal.ai

Best for: Batch processing, structured extraction, JSON pipelines

How: Best for structured output tasks. Supports response_format: json_object. No reasoning overhead.

Example: Process RSS feeds into structured summaries for pennies per 1000 articles.

API: api.moonshot.ai — OpenAI-compatible. model='moonshot-v1-8k'

Best for: RAG pipelines, semantic search, document retrieval

How: Set dimensions param to reduce size (e.g., 256 for fast search, 3072 for max quality).

Example: Index your internal docs and build a search API with pgvector + this model.

API: api.openai.com — client.embeddings.create(model='text-embedding-3-large')

Best for: life sciences research

How: N/A

Example: N/A

Auto-discovered from news articles.