300 lines
8.9 KiB
Markdown
300 lines
8.9 KiB
Markdown
# LLM Model ID Reference
|
|
|
|
List of model IDs for major LLM providers commonly used in LangGraph. For detailed information and best practices for each provider, please refer to the individual pages.
|
|
|
|
> **Last Updated**: 2025-11-24
|
|
> **Note**: Model availability and names may change. Please refer to each provider's official documentation for the latest information.
|
|
|
|
## 📚 Provider-Specific Documentation
|
|
|
|
### [Google Gemini Models](06_llm_model_ids_gemini.md)
|
|
|
|
Google's latest LLM models featuring large-scale context (up to 1M tokens).
|
|
|
|
**Key Models**:
|
|
|
|
- `google/gemini-3-pro-preview` - Latest high-performance model
|
|
- `gemini-2.5-flash` - Fast response version (1M tokens)
|
|
- `gemini-2.5-flash-lite` - Lightweight fast version
|
|
|
|
**Details**: [Gemini Model ID Complete Guide](06_llm_model_ids_gemini.md)
|
|
|
|
---
|
|
|
|
### [Anthropic Claude Models](06_llm_model_ids_claude.md)
|
|
|
|
Anthropic's Claude 4.x series featuring balanced performance and cost.
|
|
|
|
**Key Models**:
|
|
|
|
- `claude-opus-4-1-20250805` - Most powerful model
|
|
- `claude-sonnet-4-5` - Balanced (recommended)
|
|
- `claude-haiku-4-5-20251001` - Fast and low-cost
|
|
|
|
**Details**: [Claude Model ID Complete Guide](06_llm_model_ids_claude.md)
|
|
|
|
---
|
|
|
|
### [OpenAI GPT Models](06_llm_model_ids_openai.md)
|
|
|
|
OpenAI's GPT-5 series supporting a wide range of tasks, with 400K context and advanced reasoning capabilities.
|
|
|
|
**Key Models**:
|
|
|
|
- `gpt-5` - GPT-5 standard version
|
|
- `gpt-5-mini` - Small version (cost-efficient ◎)
|
|
- `gpt-5.1-thinking` - Adaptive reasoning model
|
|
|
|
**Details**: [OpenAI Model ID Complete Guide](06_llm_model_ids_openai.md)
|
|
|
|
---
|
|
|
|
## 🚀 Quick Start
|
|
|
|
### Basic Usage
|
|
|
|
```python
|
|
from langchain_anthropic import ChatAnthropic
|
|
from langchain_openai import ChatOpenAI
|
|
from langchain_google_genai import ChatGoogleGenerativeAI
|
|
|
|
# Use Claude
|
|
claude_llm = ChatAnthropic(model="claude-sonnet-4-5")
|
|
|
|
# Use OpenAI
|
|
openai_llm = ChatOpenAI(model="gpt-5")
|
|
|
|
# Use Gemini
|
|
gemini_llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash")
|
|
```
|
|
|
|
### Using with LangGraph
|
|
|
|
```python
|
|
from langgraph.graph import StateGraph
|
|
from langchain_anthropic import ChatAnthropic
|
|
from typing import TypedDict, Annotated
|
|
from langgraph.graph.message import add_messages
|
|
|
|
# State definition
|
|
class State(TypedDict):
|
|
messages: Annotated[list, add_messages]
|
|
|
|
# Model initialization
|
|
llm = ChatAnthropic(model="claude-sonnet-4-5")
|
|
|
|
# Node definition
|
|
def chat_node(state: State):
|
|
response = llm.invoke(state["messages"])
|
|
return {"messages": [response]}
|
|
|
|
# Graph construction
|
|
graph = StateGraph(State)
|
|
graph.add_node("chat", chat_node)
|
|
graph.set_entry_point("chat")
|
|
graph.set_finish_point("chat")
|
|
|
|
app = graph.compile()
|
|
```
|
|
|
|
## 📊 Model Selection Guide
|
|
|
|
### Recommended Models by Use Case
|
|
|
|
| Use Case | Recommended Model | Reason |
|
|
| ---------------------- | ------------------------------------------------------------- | ------------------------- |
|
|
| **Cost-focused** | `claude-haiku-4-5`<br>`gpt-5-mini`<br>`gemini-2.5-flash-lite` | Low cost and fast |
|
|
| **Balance-focused** | `claude-sonnet-4-5`<br>`gpt-5`<br>`gemini-2.5-flash` | Balance of performance and cost |
|
|
| **Performance-focused** | `claude-opus-4-1`<br>`gpt-5-pro`<br>`gemini-3-pro` | Maximum performance |
|
|
| **Reasoning-specialized** | `gpt-5.1-thinking`<br>`gpt-5.1-instant` | Adaptive reasoning, math, science |
|
|
| **Large-scale context** | `gemini-2.5-pro` | 1M token context |
|
|
|
|
### Selection by Task Complexity
|
|
|
|
```python
|
|
def select_model(task_complexity: str, budget: str = "normal"):
|
|
"""Select optimal model based on task and budget"""
|
|
|
|
# Budget-focused
|
|
if budget == "low":
|
|
models = {
|
|
"simple": "claude-haiku-4-5-20251001",
|
|
"medium": "gpt-5-mini",
|
|
"complex": "claude-sonnet-4-5"
|
|
}
|
|
return models.get(task_complexity, "gpt-5-mini")
|
|
|
|
# Performance-focused
|
|
if budget == "high":
|
|
models = {
|
|
"simple": "claude-sonnet-4-5",
|
|
"medium": "gpt-5",
|
|
"complex": "claude-opus-4-1-20250805"
|
|
}
|
|
return models.get(task_complexity, "claude-opus-4-1-20250805")
|
|
|
|
# Balance-focused (default)
|
|
models = {
|
|
"simple": "gpt-5-mini",
|
|
"medium": "claude-sonnet-4-5",
|
|
"complex": "gpt-5"
|
|
}
|
|
return models.get(task_complexity, "claude-sonnet-4-5")
|
|
```
|
|
|
|
## 🔄 Multi-Model Strategy
|
|
|
|
### Fallback Between Providers
|
|
|
|
```python
|
|
from langchain_anthropic import ChatAnthropic
|
|
from langchain_openai import ChatOpenAI
|
|
|
|
# Primary model and fallback
|
|
primary = ChatAnthropic(model="claude-sonnet-4-5")
|
|
fallback1 = ChatOpenAI(model="gpt-5")
|
|
fallback2 = ChatGoogleGenerativeAI(model="gemini-2.5-flash")
|
|
|
|
llm_with_fallback = primary.with_fallbacks([fallback1, fallback2])
|
|
|
|
# Automatically fallback until one model succeeds
|
|
response = llm_with_fallback.invoke("Question content")
|
|
```
|
|
|
|
### Cost-Optimized Auto-Routing
|
|
|
|
```python
|
|
from langgraph.graph import StateGraph
|
|
from typing import TypedDict, Annotated, Literal
|
|
from langgraph.graph.message import add_messages
|
|
|
|
class State(TypedDict):
|
|
messages: Annotated[list, add_messages]
|
|
complexity: Literal["simple", "medium", "complex"]
|
|
|
|
# Use different models based on complexity
|
|
simple_llm = ChatAnthropic(model="claude-haiku-4-5-20251001") # Low cost
|
|
medium_llm = ChatOpenAI(model="gpt-5-mini") # Balance
|
|
complex_llm = ChatAnthropic(model="claude-opus-4-1-20250805") # High performance
|
|
|
|
def analyze_complexity(state: State):
|
|
"""Analyze message complexity"""
|
|
message = state["messages"][-1].content
|
|
# Simple complexity determination
|
|
if len(message) < 50:
|
|
complexity = "simple"
|
|
elif len(message) < 200:
|
|
complexity = "medium"
|
|
else:
|
|
complexity = "complex"
|
|
return {"complexity": complexity}
|
|
|
|
def route_by_complexity(state: State):
|
|
"""Route based on complexity"""
|
|
routes = {
|
|
"simple": "simple_node",
|
|
"medium": "medium_node",
|
|
"complex": "complex_node"
|
|
}
|
|
return routes[state["complexity"]]
|
|
|
|
def simple_node(state: State):
|
|
response = simple_llm.invoke(state["messages"])
|
|
return {"messages": [response]}
|
|
|
|
def medium_node(state: State):
|
|
response = medium_llm.invoke(state["messages"])
|
|
return {"messages": [response]}
|
|
|
|
def complex_node(state: State):
|
|
response = complex_llm.invoke(state["messages"])
|
|
return {"messages": [response]}
|
|
|
|
# Graph construction
|
|
graph = StateGraph(State)
|
|
graph.add_node("analyze", analyze_complexity)
|
|
graph.add_node("simple_node", simple_node)
|
|
graph.add_node("medium_node", medium_node)
|
|
graph.add_node("complex_node", complex_node)
|
|
|
|
graph.set_entry_point("analyze")
|
|
graph.add_conditional_edges("analyze", route_by_complexity)
|
|
|
|
app = graph.compile()
|
|
```
|
|
|
|
## 🔧 Best Practices
|
|
|
|
### 1. Environment Variable Management
|
|
|
|
```python
|
|
import os
|
|
|
|
# Flexibly manage models with environment variables
|
|
DEFAULT_MODEL = os.getenv("DEFAULT_LLM_MODEL", "claude-sonnet-4-5")
|
|
FAST_MODEL = os.getenv("FAST_LLM_MODEL", "claude-haiku-4-5-20251001")
|
|
SMART_MODEL = os.getenv("SMART_LLM_MODEL", "claude-opus-4-1-20250805")
|
|
|
|
# Switch provider based on environment
|
|
PROVIDER = os.getenv("LLM_PROVIDER", "anthropic")
|
|
|
|
if PROVIDER == "anthropic":
|
|
llm = ChatAnthropic(model=DEFAULT_MODEL)
|
|
elif PROVIDER == "openai":
|
|
llm = ChatOpenAI(model="gpt-5")
|
|
elif PROVIDER == "google":
|
|
llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash")
|
|
```
|
|
|
|
### 2. Fixed Model Version (Production)
|
|
|
|
```python
|
|
# ✅ Recommended: Use dated version (production)
|
|
prod_llm = ChatAnthropic(model="claude-sonnet-4-20250514")
|
|
|
|
# ⚠️ Caution: No version specified (potential unexpected updates)
|
|
dev_llm = ChatAnthropic(model="claude-sonnet-4")
|
|
```
|
|
|
|
### 3. Cost Monitoring
|
|
|
|
```python
|
|
from langchain.callbacks import get_openai_callback
|
|
|
|
# OpenAI cost tracking
|
|
with get_openai_callback() as cb:
|
|
response = openai_llm.invoke("question")
|
|
print(f"Total Cost: ${cb.total_cost}")
|
|
print(f"Tokens: {cb.total_tokens}")
|
|
|
|
# For other providers, track manually
|
|
# Refer to each provider's detail pages
|
|
```
|
|
|
|
## 📖 Detailed Documentation
|
|
|
|
For detailed information on each provider, please refer to the following pages:
|
|
|
|
- **[Gemini Model ID](06_llm_model_ids_gemini.md)**: Model list, usage, advanced settings, multimodal features
|
|
- **[Claude Model ID](06_llm_model_ids_claude.md)**: Model list, platform-specific IDs, tool usage, deprecated model information
|
|
- **[OpenAI Model ID](06_llm_model_ids_openai.md)**: Model list, reasoning models, vision features, Azure OpenAI
|
|
|
|
## 🔗 Reference Links
|
|
|
|
### Official Documentation
|
|
|
|
- [Google Gemini API](https://ai.google.dev/gemini-api/docs/models)
|
|
- [Anthropic Claude API](https://docs.anthropic.com/en/docs/about-claude/models/overview)
|
|
- [OpenAI Platform](https://platform.openai.com/docs/models)
|
|
|
|
### Integration Guides
|
|
|
|
- [LangChain Chat Models](https://docs.langchain.com/oss/python/modules/model_io/chat/)
|
|
- [LangGraph Documentation](https://langchain-ai.github.io/langgraph/)
|
|
|
|
### Pricing Information
|
|
|
|
- [Gemini Pricing](https://ai.google.dev/pricing)
|
|
- [Claude Pricing](https://www.anthropic.com/pricing)
|
|
- [OpenAI Pricing](https://openai.com/pricing)
|