Address review feedback on LangGraph samples

- Drop cross-references between Functional API and Graph API READMEs so
  each stands alone (review comment 1)
- Combine run_worker.py + run_workflow.py into a single main.py for the
  langsmith_tracing samples to reduce setup steps (review comment 2)
- Fix workflow -> Workflow casing (review comment 3)
- Alias temporalio's entrypoint and graph helpers as temporal_entrypoint /
  temporal_graph at import sites to avoid the langgraph.func.entrypoint
  collision (review comment 4)
- Demonstrate @Traceable in three places in both langsmith_tracing samples:
  on the Activity/task itself, on a helper called from the Activity, and
  on a helper called from the Workflow (review comment 5)
- Drop unnecessary single-task list comprehension for activity_options in
  hello_world and langsmith_tracing functional samples (review comment 6)
- Spell out 'temporal server start-dev' in every sample README's
  prerequisites (review comment 7)
- Fix stale README references to get_cache() now that the API is cache()
  (review comment 8)
- Rename arbitrarily-named ETL pipeline functions in continue_as_new to
  honest math names (double / add_50 / triple) per review comment 9

Author: DABH

langgraph_plugin/README.md

@@ -34,13 +34,13 @@ Samples are organized by API style:
 
 ## Running a Sample
 
-Each sample has two scripts -- start the worker first, then the workflow starter in a separate terminal.
+Most samples have two scripts -- start the Worker first, then the Workflow starter in a separate terminal.
 
 ```bash
-# Terminal 1: start the worker
+# Terminal 1: start the Worker
 uv run langgraph_plugin/<api>/<sample>/run_worker.py
 
-# Terminal 2: start the workflow
+# Terminal 2: start the Workflow
 uv run langgraph_plugin/<api>/<sample>/run_workflow.py
 ```
 
@@ -54,11 +54,17 @@ uv run langgraph_plugin/graph_api/human_in_the_loop/run_worker.py
 uv run langgraph_plugin/graph_api/human_in_the_loop/run_workflow.py
 ```
 
+The LangSmith Tracing samples bundle the Worker and Workflow execution into a single `main.py`:
+
+```bash
+uv run langgraph_plugin/<api>/langsmith_tracing/main.py
+```
+
 ## Key Features Demonstrated
 
 - **Durable execution** -- Every graph node / `@task` runs as a Temporal activity with configurable timeouts and retry policies.
 - **Human-in-the-loop** -- LangGraph's `interrupt()` pauses the graph; Temporal signals deliver human input; queries expose pending state to UIs.
-- **Continue-as-new with caching** -- `get_cache()` captures completed task results; passing the cache to the next execution avoids re-running them.
+- **Continue-as-new with caching** -- `cache()` captures completed task results; passing the cache to the next execution avoids re-running them.
 - **Conditional routing** -- Graph API's `add_conditional_edges` and Functional API's native `if/else`/`while` for agent loops.
 - **Parallel execution** -- Functional API launches multiple tasks concurrently by creating futures before awaiting them.
 

langgraph_plugin/functional_api/continue_as_new/README.md

@@ -1,23 +1,23 @@
 # Continue-as-New with Caching (Functional API)
 
-Same pattern as the Graph API version, using `@task` and `@entrypoint` decorators.
+Demonstrates combining Temporal's continue-as-new with LangGraph's task result caching to avoid re-executing completed `@task` functions across workflow boundaries.
 
 ## What This Sample Demonstrates
 
-- Task result caching across continue-as-new boundaries with `get_cache()`
+- Task result caching across continue-as-new boundaries with `cache()`
 - Restoring cached results with `entrypoint(name, cache=...)`
 - Each `@task` executes exactly once despite multiple workflow invocations
 
 ## How It Works
 
-1. Three tasks run sequentially: `extract` (x2) -> `transform` (+50) -> `load` (x3).
+1. Three tasks run sequentially: `double` (x2) -> `add_50` (+50) -> `triple` (x3).
 2. After the first invocation, the workflow continues-as-new with the cache.
 3. On subsequent invocations, all tasks return cached results instantly.
 4. Input 10 -> 20 -> 70 -> 210.
 
 ## Running the Sample
 
-Prerequisites: `uv sync --group langgraph` and a running Temporal dev server.
+Prerequisites: `uv sync --group langgraph` and a running Temporal dev server (`temporal server start-dev`).
 
 ```bash
 # Terminal 1
@@ -32,5 +32,5 @@ uv run langgraph_plugin/functional_api/continue_as_new/run_workflow.py
 | File | Description |
 |------|-------------|
 | `workflow.py` | `@task` functions, `@entrypoint`, `PipelineInput`, and `PipelineFunctionalWorkflow` |
-| `run_worker.py` | Registers tasks and entrypoint with `LangGraphPlugin`, starts worker |
-| `run_workflow.py` | Executes the pipeline workflow and prints the result |
+| `run_worker.py` | Registers tasks and entrypoint with `LangGraphPlugin`, starts Worker |
+| `run_workflow.py` | Executes the pipeline Workflow and prints the result |

langgraph_plugin/functional_api/continue_as_new/workflow.py

@@ -1,46 +1,47 @@
 """Continue-as-new with caching using the LangGraph Functional API with Temporal.
 
-Same pattern as the Graph API version, but using @task and @entrypoint decorators.
+Demonstrates Temporal's continue-as-new with LangGraph's task result caching
+to avoid re-executing completed @task functions across workflow boundaries.
 """
 
 from dataclasses import dataclass
 from datetime import timedelta
 from typing import Any
 
-from langgraph.func import entrypoint as lg_entrypoint
-from langgraph.func import task
+from langgraph.func import entrypoint, task
 from temporalio import workflow
-from temporalio.contrib.langgraph import cache, entrypoint
+from temporalio.contrib.langgraph import cache
+from temporalio.contrib.langgraph import entrypoint as temporal_entrypoint
 
 
 @task
-def extract(data: int) -> int:
-    """Stage 1: Extract -- simulate data extraction by doubling the input."""
+def double(data: int) -> int:
+    """Stage 1: double the input."""
     return data * 2
 
 
 @task
-def transform(data: int) -> int:
-    """Stage 2: Transform -- simulate transformation by adding 50."""
+def add_50(data: int) -> int:
+    """Stage 2: add 50."""
     return data + 50
 
 
 @task
-def load(data: int) -> int:
-    """Stage 3: Load -- simulate loading by tripling the result."""
+def triple(data: int) -> int:
+    """Stage 3: triple the result."""
     return data * 3
 
 
-@lg_entrypoint()
+@entrypoint()
 async def pipeline_entrypoint(data: int) -> dict:
-    """Run the 3-stage pipeline: extract -> transform -> load."""
-    extracted = await extract(data)
-    transformed = await transform(extracted)
-    loaded = await load(transformed)
-    return {"result": loaded}
+    """Run the 3-stage pipeline: double -> add_50 -> triple."""
+    doubled = await double(data)
+    plus_50 = await add_50(doubled)
+    tripled = await triple(plus_50)
+    return {"result": tripled}
 
 
-all_tasks: list[Any] = [extract, transform, load]
+all_tasks: list[Any] = [double, add_50, triple]
 
 activity_options = {
     t.func.__name__: {
@@ -68,7 +69,7 @@ class PipelineFunctionalWorkflow:
 
     @workflow.run
     async def run(self, input_data: PipelineInput) -> dict[str, Any]:
-        app = entrypoint("pipeline", cache=input_data.cache)
+        app = temporal_entrypoint("pipeline", cache=input_data.cache)
         result = await app.ainvoke(input_data.data)
 
         if input_data.phase < 3:

langgraph_plugin/functional_api/control_flow/README.md

@@ -18,7 +18,7 @@ Demonstrates the Functional API's strength for complex control flow: parallel ex
 
 ## Running the Sample
 
-Prerequisites: `uv sync --group langgraph` and a running Temporal dev server.
+Prerequisites: `uv sync --group langgraph` and a running Temporal dev server (`temporal server start-dev`).
 
 ```bash
 # Terminal 1

langgraph_plugin/functional_api/control_flow/workflow.py

@@ -9,10 +9,9 @@
 from datetime import timedelta
 from typing import Any
 
-from langgraph.func import entrypoint as lg_entrypoint
-from langgraph.func import task
+from langgraph.func import entrypoint, task
 from temporalio import workflow
-from temporalio.contrib.langgraph import entrypoint
+from temporalio.contrib.langgraph import entrypoint as temporal_entrypoint
 
 
 @task
@@ -49,7 +48,7 @@ def summarize(results: list[str]) -> str:
     )
 
 
-@lg_entrypoint()
+@entrypoint()
 async def control_flow_pipeline(items: list[str]) -> dict:
     """Process a batch of items with parallel validation, sequential
     classification, and conditional routing.
@@ -97,4 +96,4 @@ async def control_flow_pipeline(items: list[str]) -> dict:
 class ControlFlowWorkflow:
     @workflow.run
     async def run(self, items: list[str]) -> dict:
-        return await entrypoint("control-flow").ainvoke(items)
+        return await temporal_entrypoint("control-flow").ainvoke(items)

langgraph_plugin/functional_api/hello_world/README.md

@@ -10,7 +10,7 @@ The simplest possible LangGraph Functional API + Temporal sample: a single `@tas
 
 ## Running the Sample
 
-Prerequisites: `uv sync --group langgraph` and a running Temporal dev server.
+Prerequisites: `uv sync --group langgraph` and a running Temporal dev server (`temporal server start-dev`).
 
 ```bash
 # Terminal 1

langgraph_plugin/functional_api/hello_world/workflow.py

@@ -4,12 +4,10 @@
 """
 
 from datetime import timedelta
-from typing import Any
 
-from langgraph.func import entrypoint as lg_entrypoint
-from langgraph.func import task
+from langgraph.func import entrypoint, task
 from temporalio import workflow
-from temporalio.contrib.langgraph import entrypoint
+from temporalio.contrib.langgraph import entrypoint as temporal_entrypoint
 
 
 @task
@@ -18,26 +16,25 @@ def process_query(query: str) -> str:
     return f"Processed: {query}"
 
 
-@lg_entrypoint()
+@entrypoint()
 async def hello_entrypoint(query: str) -> dict:
     """Process the query and return it in a result dict."""
     result = await process_query(query)
     return {"result": result}
 
 
-all_tasks: list[Any] = [process_query]
+all_tasks = [process_query]
 
 activity_options = {
-    t.func.__name__: {
+    "process_query": {
         "execute_in": "activity",
         "start_to_close_timeout": timedelta(seconds=10),
-    }
-    for t in all_tasks
+    },
 }
 
 
 @workflow.defn
 class HelloWorldFunctionalWorkflow:
     @workflow.run
     async def run(self, query: str) -> dict:
-        return await entrypoint("hello-world").ainvoke(query)
+        return await temporal_entrypoint("hello-world").ainvoke(query)

langgraph_plugin/functional_api/human_in_the_loop/README.md

@@ -1,6 +1,6 @@
 # Human-in-the-Loop Chatbot (Functional API)
 
-Same pattern as the Graph API version, but using `@task` and `@entrypoint` decorators for an imperative programming style.
+Demonstrates using LangGraph's `interrupt()` to pause an entrypoint for human review, combined with Temporal signals and queries for asynchronous feedback, using the imperative `@task`/`@entrypoint` style.
 
 ## What This Sample Demonstrates
 
@@ -18,7 +18,7 @@ Same pattern as the Graph API version, but using `@task` and `@entrypoint` decor
 
 ## Running the Sample
 
-Prerequisites: `uv sync --group langgraph` and a running Temporal dev server.
+Prerequisites: `uv sync --group langgraph` and a running Temporal dev server (`temporal server start-dev`).
 
 ```bash
 # Terminal 1

langgraph_plugin/functional_api/human_in_the_loop/workflow.py

@@ -8,11 +8,10 @@
 
 from langchain_core.runnables import RunnableConfig
 from langgraph.checkpoint.memory import InMemorySaver
-from langgraph.func import entrypoint as lg_entrypoint
-from langgraph.func import task
+from langgraph.func import entrypoint, task
 from langgraph.types import Command, interrupt
 from temporalio import workflow
-from temporalio.contrib.langgraph import entrypoint
+from temporalio.contrib.langgraph import entrypoint as temporal_entrypoint
 
 
 @task
@@ -33,7 +32,7 @@ def request_human_review(draft: str) -> str:
     return f"[Revised] {draft} (incorporating feedback: {feedback})"
 
 
-@lg_entrypoint()
+@entrypoint()
 async def chatbot_entrypoint(user_message: str) -> dict:
     """Chatbot entrypoint: generate a draft, get human review, return result."""
     draft = await generate_draft(user_message)
@@ -70,7 +69,7 @@ def get_draft(self) -> str | None:
 
     @workflow.run
     async def run(self, user_message: str) -> dict[str, Any]:
-        app = entrypoint("chatbot")
+        app = temporal_entrypoint("chatbot")
         app.checkpointer = InMemorySaver()
         config = RunnableConfig(
             {"configurable": {"thread_id": workflow.info().workflow_id}}

langgraph_plugin/functional_api/langsmith_tracing/README.md

@@ -1,33 +1,30 @@
 # LangSmith Tracing (Functional API)
 
-Same pattern as the Graph API version, using `@task` and `@entrypoint` decorators.
+Demonstrates combining `LangGraphPlugin` (durable task execution) with Temporal's `LangSmithPlugin` (observability) for full tracing of LLM calls through Temporal workflows, using LangGraph's `@task` and `@entrypoint` decorators.
 
 ## What This Sample Demonstrates
 
-- Combining `LangSmithPlugin` (observability) with `LangGraphPlugin` (durability)
-- `@traceable` decorator on a `@task` for LangSmith tracing of LLM calls
-- Both plugins working together in the Functional API style
+- Using `LangSmithPlugin` on the Temporal client for automatic trace propagation
+- Using `LangGraphPlugin` on the Worker for durable LangGraph execution
+- `@traceable` in three places: on the `@task` (Activity) itself, on a helper called from inside the `@task`, and on a helper called from inside the `@entrypoint` (Workflow)
+- Both plugins working together: durability + observability
 
 ## How It Works
 
 1. The Temporal client is created with `LangSmithPlugin(add_temporal_runs=True)`.
-2. The worker registers the `chat` task with `LangGraphPlugin`.
-3. When the workflow runs, the `chat` task executes as a Temporal activity.
-4. The `@traceable` decorator sends trace data to LangSmith.
+2. A Worker registers the `chat` task with `LangGraphPlugin`.
+3. When the Workflow runs, the `chat` task executes as a Temporal Activity.
+4. `@traceable` decorators emit trace data to LangSmith for the task, an in-task helper, and an in-entrypoint helper.
 
 ## Running the Sample
 
-Prerequisites: `uv sync --group langgraph` and a running Temporal dev server.
+Prerequisites: `uv sync --group langgraph` and a running Temporal dev server (`temporal server start-dev`).
 
 ```bash
 export ANTHROPIC_API_KEY='your-key'
 export LANGCHAIN_API_KEY='your-key'
 
-# Terminal 1
-uv run langgraph_plugin/functional_api/langsmith_tracing/run_worker.py
-
-# Terminal 2
-uv run langgraph_plugin/functional_api/langsmith_tracing/run_workflow.py
+uv run langgraph_plugin/functional_api/langsmith_tracing/main.py
 ```
 
 Traces will appear in your [LangSmith](https://smith.langchain.com/) dashboard.
@@ -36,6 +33,5 @@ Traces will appear in your [LangSmith](https://smith.langchain.com/) dashboard.
 
 | File | Description |
 |------|-------------|
-| `workflow.py` | `@traceable` chat task, `@entrypoint`, and `ChatFunctionalWorkflow` |
-| `run_worker.py` | Creates client with `LangSmithPlugin`, worker with `LangGraphPlugin` |
-| `run_workflow.py` | Creates client with `LangSmithPlugin`, executes workflow |
+| `workflow.py` | `@traceable` chat task + helpers, `@entrypoint`, and `ChatFunctionalWorkflow` |
+| `main.py` | Starts a Worker and executes the Workflow in a single process |