langgraph-init-cli 0.1.0__py3-none-any.whl

langgraph_cli/templates/production/src/app/api/app.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from src.app.api.routes import invoke_workflow
+
+
+class Application:
+    def handle(self, input_text: str) -> dict[str, object]:
+        return invoke_workflow({"input_text": input_text})
+
+
+app = Application()

langgraph_cli/templates/production/src/app/api/routes.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from src.app.config import settings
+from src.app.graph.builder import build_graph
+
+
+def invoke_workflow(payload: dict[str, object]) -> dict[str, object]:
+    app = build_graph()
+    initial_state = {
+        "input_text": payload.get("input_text", ""),
+        "retry_count": 0,
+        "messages": [],
+        "prompt_versions": payload.get("prompt_versions", settings.default_prompt_versions.copy()),
+        "tool_results": {},
+    }
+    return app.invoke(initial_state)

langgraph_cli/templates/production/src/app/config.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+@dataclass(slots=True)
+class Settings:
+    project_name: str = "{{PROJECT_NAME}}"
+    environment: str = os.getenv("APP_ENV", "development")
+    log_level: str = os.getenv("LOG_LEVEL", "INFO")
+    langsmith_tracing: bool = os.getenv("LANGSMITH_TRACING", "false").lower() == "true"
+    langsmith_endpoint: str = os.getenv("LANGSMITH_ENDPOINT", "https://api.smith.langchain.com")
+    langsmith_api_key: str = os.getenv("LANGSMITH_API_KEY", "")
+    langsmith_project: str = os.getenv("LANGSMITH_PROJECT", "{{PROJECT_NAME}}")
+    default_prompt_versions: dict[str, str] | None = None
+    max_validation_retries: int = 2
+
+    def __post_init__(self) -> None:
+        if self.default_prompt_versions is None:
+            self.default_prompt_versions = {
+                "intent": "v2",
+                "extraction": "v1",
+                "validation": "v1",
+            }
+
+    @property
+    def prompt_root(self) -> Path:
+        return Path(__file__).resolve().parent / "prompts" / "versions"
+
+
+settings = Settings()

langgraph_cli/templates/production/src/app/evaluation/__init__.py

@@ -0,0 +1 @@
+"""Evaluation package."""

langgraph_cli/templates/production/src/app/evaluation/evaluator.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+
+class Evaluator:
+    def evaluate(self, extracted: dict[str, object], prompt: str) -> dict[str, object]:
+        populated = [value for value in extracted.values() if value not in ("", None, [], {})]
+        total_fields = max(len(extracted), 1)
+        coverage = len(populated) / total_fields
+        return {
+            "field_coverage": round(coverage, 2),
+            "checked_with_prompt": bool(prompt),
+        }

langgraph_cli/templates/production/src/app/evaluation/scoring.py

@@ -0,0 +1,2 @@
+def score_validation(field_coverage: float, confidence: float) -> float:
+    return round((field_coverage * 0.6) + (confidence * 0.4), 2)

langgraph_cli/templates/production/src/app/graph/__init__.py

@@ -0,0 +1 @@
+"""Graph package."""

langgraph_cli/templates/production/src/app/graph/builder.py

@@ -0,0 +1,20 @@
+from langgraph.graph import END, START, StateGraph
+
+from src.app.graph.constants import Names
+from src.app.graph.edges import EDGE_MAP, route_after_validation
+from src.app.graph.registry import NODE_REGISTRY
+from src.app.graph.state import WorkflowState
+
+
+def build_graph():
+    graph = StateGraph(WorkflowState)
+    for name, node in NODE_REGISTRY.items():
+        graph.add_node(name, node)
+
+    graph.add_edge(START, Names.INTENT)
+    graph.add_edge(Names.INTENT, Names.PROCESSING)
+    graph.add_edge(Names.PROCESSING, Names.VALIDATION)
+    graph.add_conditional_edges(Names.VALIDATION, route_after_validation, EDGE_MAP)
+    graph.add_edge(Names.OUTPUT, END)
+    graph.add_edge(Names.ERROR, END)
+    return graph.compile()

langgraph_cli/templates/production/src/app/graph/constants.py

@@ -0,0 +1,28 @@
+from src.app.nodes.error import error_node
+from src.app.nodes.intent import intent_node
+from src.app.nodes.output import output_node
+from src.app.nodes.processing import processing_node
+from src.app.nodes.validation import validation_node
+
+
+class Names:
+    INTENT = "intent"
+    PROCESSING = "processing"
+    VALIDATION = "validation"
+    OUTPUT = "output"
+    ERROR = "error"
+
+
+class Tags:
+    CONTINUE = "continue"
+    RETRY = "retry"
+    COMPLETE = "complete"
+    ERROR = "error"
+
+
+class Nodes:
+    INTENT = intent_node
+    PROCESSING = processing_node
+    VALIDATION = validation_node
+    OUTPUT = output_node
+    ERROR = error_node

langgraph_cli/templates/production/src/app/graph/edges.py

@@ -0,0 +1,21 @@
+from src.app.config import settings
+from src.app.graph.constants import Names, Tags
+from src.app.graph.state import WorkflowState
+
+
+def route_after_validation(state: WorkflowState) -> str:
+    validation = state.get("validation", {})
+    if state.get("error"):
+        return Tags.ERROR
+    if validation.get("is_valid"):
+        return Tags.COMPLETE
+    if state.get("retry_count", 0) < settings.max_validation_retries:
+        return Tags.RETRY
+    return Tags.ERROR
+
+
+EDGE_MAP = {
+    Tags.COMPLETE: Names.OUTPUT,
+    Tags.RETRY: Names.PROCESSING,
+    Tags.ERROR: Names.ERROR,
+}

langgraph_cli/templates/production/src/app/graph/registry.py

@@ -0,0 +1,10 @@
+from src.app.graph.constants import Names, Nodes
+
+
+NODE_REGISTRY = {
+    Names.INTENT: Nodes.INTENT,
+    Names.PROCESSING: Nodes.PROCESSING,
+    Names.VALIDATION: Nodes.VALIDATION,
+    Names.OUTPUT: Nodes.OUTPUT,
+    Names.ERROR: Nodes.ERROR,
+}

langgraph_cli/templates/production/src/app/graph/state.py

@@ -0,0 +1,15 @@
+from typing import Any, TypedDict
+
+
+class WorkflowState(TypedDict, total=False):
+    input_text: str
+    intent: str
+    extracted_data: dict[str, Any]
+    validation: dict[str, Any]
+    output: str
+    error: str
+    confidence: float
+    retry_count: int
+    messages: list[str]
+    prompt_versions: dict[str, str]
+    tool_results: dict[str, Any]

langgraph_cli/templates/production/src/app/main.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from src.app.config import settings
+from src.app.graph.builder import build_graph
+from src.app.observability.metrics import metrics
+from src.app.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def run():
+    app = build_graph()
+    sample_state = {
+        "input_text": "Please calculate 12 + 7 and validate the answer.",
+        "retry_count": 0,
+        "messages": [],
+        "prompt_versions": settings.default_prompt_versions.copy(),
+        "tool_results": {},
+    }
+    result = app.invoke(sample_state)
+    logger.info("workflow_complete", extra={"output": result.get("output"), "metrics": metrics.snapshot()})
+    print(result.get("output", "No output produced."))
+    return result
+
+
+if __name__ == "__main__":
+    run()

langgraph_cli/templates/production/src/app/models/__init__.py

@@ -0,0 +1 @@
+"""Models package."""

langgraph_cli/templates/production/src/app/models/schema.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(slots=True)
+class ExtractionSchema:
+    numbers: list[int] = field(default_factory=list)
+    prompt_used: str = ""
+    requires_tool: bool = False
+    text_length: int = 0

langgraph_cli/templates/production/src/app/models/workflow.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(slots=True)
+class WorkflowResult:
+    intent: str
+    confidence: float
+    status: str
+    validation_reason: str
+    tool_results: dict[str, object] = field(default_factory=dict)
+
+    @classmethod
+    def from_state(cls, state):
+        validation = state.get("validation", {})
+        return cls(
+            intent=state.get("intent", "unknown"),
+            confidence=state.get("confidence", 0.0),
+            status="success" if validation.get("is_valid") else "failed",
+            validation_reason=validation.get("reason", "No validation result."),
+            tool_results=state.get("tool_results", {}),
+        )
+
+    def render(self) -> str:
+        return (
+            f"intent={self.intent}; confidence={self.confidence:.2f}; "
+            f"status={self.status}; validation={self.validation_reason}; "
+            f"tools={self.tool_results}"
+        )

langgraph_cli/templates/production/src/app/nodes/__init__.py

@@ -0,0 +1 @@
+"""Node package."""

langgraph_cli/templates/production/src/app/nodes/error.py

@@ -0,0 +1,7 @@
+from src.app.graph.state import WorkflowState
+
+
+def error_node(state: WorkflowState) -> WorkflowState:
+    validation = state.get("validation", {})
+    error = state.get("error") or validation.get("reason") or "Workflow failed validation."
+    return {"output": f"ERROR: {error}", "error": error}

langgraph_cli/templates/production/src/app/nodes/intent.py

@@ -0,0 +1,21 @@
+from src.app.graph.state import WorkflowState
+from src.app.services.llm_service import LLMService
+from src.app.services.prompt_service import PromptService
+from src.app.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def intent_node(state: WorkflowState) -> WorkflowState:
+    prompt_service = PromptService()
+    llm_service = LLMService(prompt_service=prompt_service)
+    user_input = state.get("input_text", "")
+    version = state.get("prompt_versions", {}).get("intent")
+    prompt = prompt_service.load_prompt("intent", version=version)
+    intent_result = llm_service.classify_intent(prompt=prompt, text=user_input)
+    logger.info("intent_node", extra={"intent": intent_result["intent"], "confidence": intent_result["confidence"]})
+    return {
+        "intent": intent_result["intent"],
+        "confidence": intent_result["confidence"],
+        "messages": state.get("messages", []) + [f"intent:{intent_result['intent']}"],
+    }

langgraph_cli/templates/production/src/app/nodes/output.py

@@ -0,0 +1,13 @@
+from src.app.graph.state import WorkflowState
+from src.app.models.workflow import WorkflowResult
+from src.app.storage.workflow_store import WorkflowStore
+from src.app.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def output_node(state: WorkflowState) -> WorkflowState:
+    result = WorkflowResult.from_state(state)
+    WorkflowStore().save(result)
+    logger.info("output_node", extra={"status": result.status})
+    return {"output": result.render()}

langgraph_cli/templates/production/src/app/nodes/processing.py

@@ -0,0 +1,32 @@
+from src.app.graph.state import WorkflowState
+from src.app.services.llm_service import LLMService
+from src.app.services.prompt_service import PromptService
+from src.app.services.tool_service import ToolService
+from src.app.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def processing_node(state: WorkflowState) -> WorkflowState:
+    prompt_service = PromptService()
+    llm_service = LLMService(prompt_service=prompt_service)
+    tool_service = ToolService()
+    prompt_version = state.get("prompt_versions", {}).get("extraction")
+    prompt = prompt_service.load_prompt("extraction", version=prompt_version)
+    enrichment = llm_service.parallel_enrich(prompt=prompt, text=state.get("input_text", ""))
+    tool_payload = tool_service.execute_for_intent(
+        intent=state.get("intent", "general"),
+        text=state.get("input_text", ""),
+        extracted=enrichment["extraction"],
+    )
+    extracted_data = {
+        **enrichment["extraction"],
+        "analysis": enrichment["analysis"],
+    }
+    logger.info("processing_node", extra={"extracted_keys": list(extracted_data.keys()), "tool_count": len(tool_payload)})
+    return {
+        "extracted_data": extracted_data,
+        "tool_results": tool_payload,
+        "retry_count": state.get("retry_count", 0) + 1,
+        "messages": state.get("messages", []) + ["processed"],
+    }

langgraph_cli/templates/production/src/app/nodes/validation.py

@@ -0,0 +1,22 @@
+from src.app.graph.state import WorkflowState
+from src.app.services.evaluation_service import EvaluationService
+from src.app.services.prompt_service import PromptService
+from src.app.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def validation_node(state: WorkflowState) -> WorkflowState:
+    prompt_service = PromptService()
+    evaluation_service = EvaluationService()
+    validation_prompt = prompt_service.load_prompt(
+        "validation",
+        version=state.get("prompt_versions", {}).get("validation"),
+    )
+    validation = evaluation_service.validate(
+        extracted=state.get("extracted_data", {}),
+        confidence=state.get("confidence", 0.0),
+        prompt=validation_prompt,
+    )
+    logger.info("validation_node", extra={"validation": validation})
+    return {"validation": validation, "messages": state.get("messages", []) + ["validated"]}

langgraph_cli/templates/production/src/app/observability/__init__.py

@@ -0,0 +1 @@
+"""Observability package."""

langgraph_cli/templates/production/src/app/observability/langsmith.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import functools
+import os
+from collections.abc import Callable
+
+from src.app.config import settings
+from src.app.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def configure_langsmith() -> None:
+    os.environ.setdefault("LANGSMITH_TRACING", str(settings.langsmith_tracing).lower())
+    os.environ.setdefault("LANGSMITH_ENDPOINT", settings.langsmith_endpoint)
+    if settings.langsmith_api_key:
+        os.environ.setdefault("LANGSMITH_API_KEY", settings.langsmith_api_key)
+    os.environ.setdefault("LANGSMITH_PROJECT", settings.langsmith_project)
+
+
+def traceable(name: str) -> Callable:
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            configure_langsmith()
+            logger.info("langsmith_trace", extra={"name": name, "enabled": settings.langsmith_tracing})
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

langgraph_cli/templates/production/src/app/observability/metrics.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+
+class Metrics:
+    def __init__(self) -> None:
+        self._counters: dict[str, int] = {}
+
+    def increment(self, name: str, amount: int = 1) -> None:
+        self._counters[name] = self._counters.get(name, 0) + amount
+
+    def snapshot(self) -> dict[str, int]:
+        return dict(self._counters)
+
+
+metrics = Metrics()

langgraph_cli/templates/production/src/app/prompts/__init__.py

@@ -0,0 +1 @@
+"""Prompts package."""

langgraph_cli/templates/production/src/app/prompts/registry.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from src.app.config import settings
+
+
+class PromptRegistry:
+    def __init__(self) -> None:
+        self.root = Path(settings.prompt_root)
+
+    def resolve_version(self, task: str, version: str | None = None) -> str:
+        return version or settings.default_prompt_versions.get(task, "v1")
+
+    def load(self, task: str, version: str | None = None) -> str:
+        selected = self.resolve_version(task, version)
+        prompt_path = self.root / task / f"{selected}.txt"
+        if not prompt_path.exists():
+            prompt_path = self.root / task / "v1.txt"
+        return prompt_path.read_text(encoding="utf-8").strip()

langgraph_cli/templates/production/src/app/prompts/versions/extraction/v1.txt

@@ -0,0 +1 @@
+Extract structured fields that can support downstream validation and tool execution.

langgraph_cli/templates/production/src/app/prompts/versions/intent/v1.txt

@@ -0,0 +1 @@
+Classify the user request into one of: general, calculation, validation.

langgraph_cli/templates/production/src/app/prompts/versions/intent/v2.txt

@@ -0,0 +1 @@
+Classify the request with strong preference for deterministic intents. Use calculation when math symbols or arithmetic verbs appear.

langgraph_cli/templates/production/src/app/prompts/versions/validation/v1.txt

@@ -0,0 +1 @@
+Validate that extraction produced enough fields and confidence to produce a final answer.

langgraph_cli/templates/production/src/app/services/__init__.py

@@ -0,0 +1 @@
+"""Services package."""

langgraph_cli/templates/production/src/app/services/evaluation_service.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from src.app.evaluation.evaluator import Evaluator
+from src.app.evaluation.scoring import score_validation
+
+
+class EvaluationService:
+    def __init__(self) -> None:
+        self.evaluator = Evaluator()
+
+    def validate(self, extracted: dict[str, object], confidence: float, prompt: str) -> dict[str, object]:
+        evaluation = self.evaluator.evaluate(extracted=extracted, prompt=prompt)
+        evaluation["confidence_score"] = score_validation(field_coverage=evaluation["field_coverage"], confidence=confidence)
+        evaluation["is_valid"] = evaluation["field_coverage"] >= 0.5 and evaluation["confidence_score"] >= 0.5
+        if evaluation["is_valid"]:
+            evaluation["reason"] = "Validation passed."
+        else:
+            evaluation["reason"] = "Validation failed because coverage or confidence was too low."
+        return evaluation

langgraph_cli/templates/production/src/app/services/llm_service.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from langchain_core.runnables import RunnableLambda, RunnableParallel
+
+from src.app.observability.langsmith import traceable
+from src.app.observability.metrics import metrics
+from src.app.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+@dataclass(slots=True)
+class LLMService:
+    prompt_service: object
+
+    @traceable(name="classify_intent")
+    def classify_intent(self, prompt: str, text: str) -> dict[str, object]:
+        lowered = text.lower()
+        intent = "general"
+        confidence = 0.55
+        if any(token in lowered for token in ("calculate", "+", "-", "*", "/")):
+            intent = "calculation"
+            confidence = 0.93
+        elif "validate" in lowered:
+            intent = "validation"
+            confidence = 0.8
+        metrics.increment("llm.classify_intent.calls")
+        logger.info("classify_intent", extra={"prompt_preview": prompt[:40], "intent": intent})
+        return {"intent": intent, "confidence": confidence}
+
+    @traceable(name="parallel_enrich")
+    def parallel_enrich(self, prompt: str, text: str) -> dict[str, dict[str, object]]:
+        extractor = RunnableLambda(lambda payload: self._extract_fields(prompt=payload["prompt"], text=payload["text"]))
+        analyzer = RunnableLambda(lambda payload: self._derive_analysis(text=payload["text"]))
+        pipeline = RunnableParallel(extraction=extractor, analysis=analyzer)
+        metrics.increment("llm.parallel_enrich.calls")
+        return pipeline.invoke({"prompt": prompt, "text": text})
+
+    def _extract_fields(self, prompt: str, text: str) -> dict[str, object]:
+        numbers = [int(match) for match in re.findall(r"-?\d+", text)]
+        return {
+            "prompt_used": prompt.splitlines()[0] if prompt else "missing-prompt",
+            "numbers": numbers,
+            "requires_tool": bool(numbers),
+            "text_length": len(text),
+        }
+
+    def _derive_analysis(self, text: str) -> dict[str, object]:
+        lowered = text.lower()
+        return {
+            "contains_validation": "validate" in lowered,
+            "contains_math": any(token in lowered for token in ("calculate", "+", "-", "*", "/")),
+        }