Initial commit

skills/langgraph-master/02_graph_architecture_prompt_chaining.md

@@ -0,0 +1,138 @@
+# Prompt Chaining (Sequential Processing)
+
+A sequential pattern where each LLM call processes the previous output.
+
+## Overview
+
+Prompt Chaining is a pattern that **chains multiple LLM calls in sequence**. The output of each step becomes the input for the next step.
+
+## Use Cases
+
+- Stepwise processing like translation → summary → analysis
+- Content generation → validation → correction pipeline
+- Data extraction → transformation → validation flow
+
+## Implementation Example
+
+```python
+from langgraph.graph import StateGraph, START, END
+from typing import TypedDict
+
+class State(TypedDict):
+    text: str
+    translated: str
+    summarized: str
+    analyzed: str
+
+def translate_node(state: State):
+    """Translate English → Japanese"""
+    translated = llm.invoke(
+        f"Translate to Japanese: {state['text']}"
+    )
+    return {"translated": translated}
+
+def summarize_node(state: State):
+    """Summarize translated text"""
+    summarized = llm.invoke(
+        f"Summarize this text: {state['translated']}"
+    )
+    return {"summarized": summarized}
+
+def analyze_node(state: State):
+    """Analyze summary"""
+    analyzed = llm.invoke(
+        f"Analyze sentiment: {state['summarized']}"
+    )
+    return {"analyzed": analyzed}
+
+# Build graph
+builder = StateGraph(State)
+builder.add_node("translate", translate_node)
+builder.add_node("summarize", summarize_node)
+builder.add_node("analyze", analyze_node)
+
+# Edges for sequential execution
+builder.add_edge(START, "translate")
+builder.add_edge("translate", "summarize")
+builder.add_edge("summarize", "analyze")
+builder.add_edge("analyze", END)
+
+graph = builder.compile()
+```
+
+## Benefits
+
+✅ **Simple**: Processing flow is linear and easy to understand
+✅ **Predictable**: Always executes in the same order
+✅ **Easy to Debug**: Each step can be tested independently
+✅ **Gradual Improvement**: Quality improves at each step
+
+## Considerations
+
+⚠️ **Accumulated Delay**: Takes time as each step executes sequentially
+⚠️ **Error Propagation**: Earlier errors affect later stages
+⚠️ **Lack of Flexibility**: Dynamic branching is difficult
+
+## Advanced Patterns
+
+### Pattern 1: Chain with Validation
+
+```python
+def validate_translation(state: State):
+    """Validate translation quality"""
+    is_valid = check_quality(state["translated"])
+    return {"is_valid": is_valid}
+
+def route_after_validation(state: State):
+    if state["is_valid"]:
+        return "continue"
+    return "retry"
+
+# Validation → continue or retry
+builder.add_conditional_edges(
+    "validate",
+    route_after_validation,
+    {
+        "continue": "summarize",
+        "retry": "translate"
+    }
+)
+```
+
+### Pattern 2: Gradual Refinement
+
+```python
+def draft_node(state: State):
+    """Create draft"""
+    draft = llm.invoke(f"Write a draft: {state['topic']}")
+    return {"draft": draft}
+
+def refine_node(state: State):
+    """Refine draft"""
+    refined = llm.invoke(f"Improve this draft: {state['draft']}")
+    return {"refined": refined}
+
+def polish_node(state: State):
+    """Final polish"""
+    polished = llm.invoke(f"Polish this text: {state['refined']}")
+    return {"final": polished}
+```
+
+## vs Other Patterns
+
+| Pattern | Prompt Chaining | Parallelization |
+|---------|----------------|-----------------|
+| Execution Order | Sequential | Parallel |
+| Dependencies | Yes | No |
+| Execution Time | Long | Short |
+| Use Case | Stepwise processing | Independent tasks |
+
+## Summary
+
+Prompt Chaining is the simplest pattern, optimal for **cases requiring stepwise processing**. Use when each step depends on the previous step.
+
+## Related Pages
+
+- [02_graph_architecture_parallelization.md](02_graph_architecture_parallelization.md) - Comparison with parallel processing
+- [02_graph_architecture_evaluator_optimizer.md](02_graph_architecture_evaluator_optimizer.md) - Combination with validation loop
+- [01_core_concepts_edge.md](01_core_concepts_edge.md) - Edge basics