Add README documentation for each Functional API sample

Each sample now has its own README explaining:
- Overview and architecture diagram
- Key code patterns with examples
- Why Temporal adds value
- Running instructions
- Customization examples

Samples documented:
- hello_world: Basic @entrypoint and @task usage
- react_agent: Tool-calling agent with observation loop
- reflection: Generate-critique-revise iteration
- agentic_rag: Adaptive retrieval with query rewriting
- deep_research: Parallel search and synthesis
- plan_and_execute: Structured plan execution
- supervisor: Multi-agent coordination
- human_in_the_loop: interrupt() for approval workflows

Author: mfateev

langgraph_plugin/functional_api/agentic_rag/README.md

@@ -0,0 +1,134 @@
+# Agentic RAG (Functional API)
+
+Retrieval-Augmented Generation with document grading and query rewriting for improved answer quality.
+
+## Overview
+
+Unlike simple RAG, agentic RAG evaluates retrieved documents and adapts:
+
+1. **Retrieve** - Fetch documents for the query
+2. **Grade** - Evaluate document relevance
+3. **Rewrite** - If not relevant, reformulate query
+4. **Generate** - Create answer from relevant documents
+
+## Architecture
+
+```
+User Question
+      │
+      ▼
+┌─────────────────┐
+│retrieve_documents│◄─────────┐
+│     (task)       │          │
+└────────┬─────────┘          │
+         │                    │
+         ▼                    │
+┌─────────────────┐           │
+│ grade_documents │           │
+│     (task)      │           │
+└────────┬────────┘           │
+         │                    │
+         ▼                    │
+    Relevant?                 │
+         │                    │
+    YES  │    NO              │
+         │     │              │
+         │     ▼              │
+         │  ┌──────────────┐  │
+         │  │ rewrite_query│──┘
+         │  │    (task)    │
+         │  └──────────────┘
+         ▼
+┌─────────────────┐
+│ generate_answer │
+│     (task)      │
+└─────────────────┘
+```
+
+## Key Code
+
+### Adaptive Retrieval Loop
+
+```python
+@entrypoint()
+async def agentic_rag_entrypoint(question: str, max_retries: int = 2) -> dict:
+    current_query = question
+
+    for attempt in range(max_retries + 1):
+        # Retrieve documents
+        documents = await retrieve_documents(current_query)
+
+        # Grade for relevance
+        grade_result = await grade_documents(question, documents)
+
+        if grade_result["relevant"]:
+            # Generate answer with relevant docs
+            answer = await generate_answer(question, documents)
+            return {"answer": answer, "status": "success"}
+
+        # Rewrite query and retry
+        if attempt < max_retries:
+            current_query = await rewrite_query(current_query)
+
+    # Best-effort answer with all retrieved docs
+    return {"answer": await generate_answer(question, all_docs), "status": "max_retries"}
+```
+
+### Document Grading
+
+```python
+@task
+def grade_documents(question: str, documents: list) -> dict:
+    """Evaluate if documents are relevant to the question."""
+    relevant_docs = [doc for doc in documents if is_relevant(doc, question)]
+    return {
+        "relevant": len(relevant_docs) >= threshold,
+        "relevant_count": len(relevant_docs)
+    }
+```
+
+## Why Temporal?
+
+- **Reliability**: Multiple retrieval attempts complete reliably
+- **Observability**: See which queries succeeded/failed
+- **Retries**: Handle API failures in retrieval/LLM calls
+- **Audit trail**: Track query rewrites in workflow history
+
+## Running the Sample
+
+1. Start Temporal:
+   ```bash
+   temporal server start-dev
+   ```
+
+2. Run with API key:
+   ```bash
+   export OPENAI_API_KEY=your-key
+   uv run langgraph_plugin/functional_api/agentic_rag/run_worker.py
+   ```
+
+3. Execute a question:
+   ```bash
+   uv run langgraph_plugin/functional_api/agentic_rag/run_workflow.py
+   ```
+
+## Customization
+
+### Adjust Relevance Threshold
+
+```python
+@task
+def grade_documents(question: str, documents: list) -> dict:
+    # Require more relevant documents
+    return {"relevant": relevant_count >= 3}
+```
+
+### Add Query Transformation Strategies
+
+```python
+@task
+def rewrite_query(query: str) -> str:
+    strategies = ["simplify", "expand", "rephrase"]
+    # Try different rewriting approaches
+    ...
+```

langgraph_plugin/functional_api/deep_research/README.md

@@ -0,0 +1,133 @@
+# Deep Research Agent (Functional API)
+
+A multi-step research agent that plans queries, executes parallel searches, and synthesizes findings into a comprehensive report.
+
+## Overview
+
+The deep research pattern:
+
+1. **Plan** - Generate research queries based on topic
+2. **Search** - Execute searches in parallel
+3. **Evaluate** - Check if results are sufficient
+4. **Iterate** - Refine and search again if needed
+5. **Synthesize** - Create final report
+
+## Architecture
+
+```
+Research Topic
+      │
+      ▼
+┌──────────────┐
+│ plan_research│
+│    (task)    │
+└──────┬───────┘
+       │
+       ▼
+┌──────────────────────────────┐
+│     execute_search (task)    │
+│  ┌────┐ ┌────┐ ┌────┐ ┌────┐│  ← Parallel execution
+│  │ Q1 │ │ Q2 │ │ Q3 │ │ Q4 ││
+│  └────┘ └────┘ └────┘ └────┘│
+└──────────────┬───────────────┘
+               │
+               ▼
+        Enough results?
+               │
+          NO   │   YES
+               │    │
+        ┌──────┘    │
+        │           ▼
+        │    ┌──────────────────┐
+        │    │ synthesize_report│
+        │    │      (task)      │
+        │    └──────────────────┘
+        │
+        └──► Plan more queries...
+```
+
+## Key Code
+
+### Parallel Search Execution
+
+```python
+@entrypoint()
+async def deep_research_entrypoint(topic: str, max_iterations: int = 2) -> dict:
+    all_results = []
+
+    for iteration in range(1, max_iterations + 1):
+        # Plan research queries
+        queries = await plan_research(topic)
+
+        # Execute searches IN PARALLEL
+        search_futures = [execute_search(q["query"], q["purpose"]) for q in queries]
+        search_results = [await future for future in search_futures]
+        all_results.extend(search_results)
+
+        # Check if we have enough relevant results
+        relevant_count = sum(1 for r in search_results if r.get("relevant"))
+        if relevant_count >= 2:
+            break
+
+    # Synthesize final report
+    report = await synthesize_report(topic, all_results)
+    return {"report": report, "total_searches": len(all_results)}
+```
+
+### Parallel Pattern
+
+```python
+# Start all tasks concurrently (non-blocking)
+futures = [execute_search(q) for q in queries]
+
+# Wait for all to complete
+results = [await f for f in futures]
+```
+
+This is the key difference from Graph API - parallel execution uses simple Python patterns.
+
+## Why Temporal?
+
+- **Parallel durability**: All concurrent searches complete reliably
+- **Cost efficiency**: Parallel execution reduces total time
+- **Progress tracking**: See individual search completions
+- **Resume**: Continue from last completed search if interrupted
+
+## Running the Sample
+
+1. Start Temporal:
+   ```bash
+   temporal server start-dev
+   ```
+
+2. Run with API key:
+   ```bash
+   export OPENAI_API_KEY=your-key
+   uv run langgraph_plugin/functional_api/deep_research/run_worker.py
+   ```
+
+3. Research a topic:
+   ```bash
+   uv run langgraph_plugin/functional_api/deep_research/run_workflow.py
+   ```
+
+## Customization
+
+### Adjust Search Breadth
+
+```python
+@task
+def plan_research(topic: str) -> list[dict]:
+    # Generate more or fewer queries
+    return generate_queries(topic, count=6)  # Default might be 4
+```
+
+### Add Source Filtering
+
+```python
+@task
+def execute_search(query: str, purpose: str) -> dict:
+    # Filter to specific sources
+    results = search(query, sources=["academic", "news"])
+    ...
+```

langgraph_plugin/functional_api/hello_world/README.md

@@ -0,0 +1,81 @@
+# Hello World (Functional API)
+
+A minimal example demonstrating the LangGraph Functional API with Temporal integration.
+
+## Overview
+
+This sample shows the basic pattern for using `@task` and `@entrypoint` decorators with Temporal:
+
+1. **`@task`** - Defines a function that runs as a Temporal activity
+2. **`@entrypoint`** - Orchestrates tasks, runs in the Temporal workflow
+
+## Key Concepts
+
+### Task as Activity
+
+```python
+@task
+def process_query(query: str) -> str:
+    """This runs as a Temporal activity with automatic retries."""
+    return f"Processed: {query}"
+```
+
+### Entrypoint as Orchestrator
+
+```python
+@entrypoint()
+async def hello_world_entrypoint(query: str) -> dict:
+    # Use await to call tasks (required for Temporal)
+    result = await process_query(query)
+    return {"query": query, "result": result}
+```
+
+### Workflow Wrapper
+
+```python
+@workflow.defn
+class HelloWorldWorkflow:
+    @workflow.run
+    async def run(self, query: str) -> dict:
+        app = compile_functional("hello_world")
+        return await app.ainvoke(query)
+```
+
+## Running the Sample
+
+1. Start Temporal server:
+   ```bash
+   temporal server start-dev
+   ```
+
+2. Run the worker:
+   ```bash
+   uv run langgraph_plugin/functional_api/hello_world/run_worker.py
+   ```
+
+3. Execute the workflow:
+   ```bash
+   uv run langgraph_plugin/functional_api/hello_world/run_workflow.py
+   ```
+
+## Files
+
+| File | Description |
+|------|-------------|
+| `tasks.py` | `@task` function definitions |
+| `entrypoint.py` | `@entrypoint` orchestration logic |
+| `workflow.py` | Temporal workflow wrapper |
+| `run_worker.py` | Worker startup script |
+| `run_workflow.py` | Workflow execution script |
+
+## Adapting from Standard LangGraph
+
+```python
+# Standard LangGraph
+result = my_task(input).result()  # Blocking
+
+# Temporal-compatible
+result = await my_task(input)  # Async await
+```
+
+See the main README for the complete migration guide.