Initial commit

2025-11-29 18:45:58 +08:00
commit 4b6db3349f
68 changed files with 15165 additions and 0 deletions
--- a/skills/langgraph-master/06_llm_model_ids.md
+++ b/skills/langgraph-master/06_llm_model_ids.md
@@ -0,0 +1,299 @@
+# 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)