graph-agents-cli 0.3.1__py3-none-any.whl

graph_agents_cli/scaffold/__init__.py

@@ -0,0 +1,19 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Scaffold package — project scaffolding, enhancement, and CI/CD setup.
+
+Provides the core logic for creating, enhancing, and upgrading
+agent projects.
+"""

graph_agents_cli/scaffold/agents/README.md

@@ -0,0 +1,24 @@
+# Agent templates
+
+Bundled templates that `graph-agents-cli create --agent <name>` renders on top of
+`base_templates/` and `deployment_targets/`:
+
+| Template | Purpose |
+|---|---|
+| `langgraph` | The LangGraph agent: `app/agent.py` exports `graph`, `app/fast_api_app.py` exports `app` (chat SSE API, A2A, health, dev playground), auth policy adapter (shared-bearer, jwt, custom), policy-enforcing API client (`api-policy.yaml`), tests, evals, two runtime locks, both Dockerfiles. Targets: `kubernetes`, `none`. |
+| `empty_py` | Hidden, framework-neutral base a framework template builds on. Ships no agent, dependencies or lock. |
+
+Layering (see `utils/template.py`): `base_templates/_shared` -> `base_templates/python`
+-> `deployment_targets/<target>/{_shared,python}` -> the agent template (its `app/`,
+`tests/`, `deployment/` and every other top-level item). Cookiecutter renders
+everything except Helm `templates/`, `*.tpl`, `.github/workflows/*` and `*.lock`,
+which are copied verbatim; project-specific values for those go through rendered
+files (`Chart.yaml`, `values*.yaml`, `.github/agent.env`). The variables a template
+may use are defined by the scaffold configuration and template tests.
+
+Regenerate the `langgraph` template's `uv-fastapi.lock` and `uv-langgraph-server.lock`
+after changing its `pyproject.toml` (render it per runtime, `uv lock`, replace the
+project name with `{{cookiecutter.project_name}}`); `tests/template/` renders and
+installs the template to prove the locks match.
+
+Remote templates (`--agent org/repo/path@ref`) follow the same layout.

graph_agents_cli/scaffold/agents/empty_py/.template/templateconfig.yaml

@@ -0,0 +1,22 @@
+# Copyright 2026 Google LLC
+# Modifications Copyright 2026 graph-agents-cli contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+description: "Empty project scaffold (no agent or framework) - the base a framework template builds on"
+hidden: true
+example_question: "Hello!"
+settings:
+  language: "python"
+  deployment_targets: ["kubernetes", "none"]
+  tags: ["empty"]

graph_agents_cli/scaffold/agents/langgraph/.env.example

@@ -0,0 +1,292 @@
+# {{cookiecutter.project_name}}: local development configuration.
+# Copy to .env (git-ignored). `graph-agents-cli deploy --env <env>` and
+# `graph-agents-cli secrets apply --env <env>` read .env.<env> (only dev falls
+# back to this .env, so local keys never reach staging or prod) and export ONLY
+# the keys listed under `secrets.keys` in graph-agents-cli-manifest.yaml into
+# the environment's Kubernetes Secret.
+# Everything else below is non-secret configuration that the Helm chart sets
+# from deployment/helm/{{cookiecutter.project_name}}/values*.yaml.
+
+# --- Application ------------------------------------------------------------
+# Exactly `dev` enables GET /playground, /docs and the dev-only relaxations;
+# any other value (prod, staging, DEV, unset) is a deployed environment.
+APP_ENV=dev
+# Port the server listens on (uvicorn under fastapi, the server under langgraph-server).
+PORT=8000
+
+# --- Agent model (LangChain init_chat_model) --------------------------------
+# openai | anthropic | gemini | openai-compatible  (fake is test-only)
+MODEL_PROVIDER={{cookiecutter.model_provider}}
+MODEL_NAME={{cookiecutter.model}}
+{% if cookiecutter.model_provider == 'openai-compatible' -%}
+# Base URL of the OpenAI-compatible endpoint (Ollama, vLLM, TGI, ...).
+OPENAI_BASE_URL=http://localhost:11434/v1
+{% else -%}
+# Only for MODEL_PROVIDER=openai-compatible (Ollama, vLLM, TGI, ...).
+# OPENAI_BASE_URL=http://localhost:11434/v1
+{% endif -%}
+# Provider key (Secret). openai -> OPENAI_API_KEY, anthropic -> ANTHROPIC_API_KEY,
+# gemini -> GOOGLE_API_KEY (AI Studio), openai-compatible -> MODEL_API_KEY.
+{{cookiecutter.provider_key_var}}=
+# OpenAI-API models only (openai, openai-compatible; set for another provider,
+# startup refuses). Reasoning effort: none | minimal | low | medium | high |
+# xhigh (unset: the model's default). The API: true = the Responses API
+# (/v1/responses), false = Chat Completions; unset lets langchain-openai choose
+# (Chat Completions but for the models it knows need the Responses API). A model
+# that refuses function tools with a reasoning effort on Chat Completions needs
+# MODEL_USE_RESPONSES_API=true (or MODEL_REASONING_EFFORT=none); a server with no
+# /v1/responses needs false or unset.
+# MODEL_REASONING_EFFORT=
+# MODEL_USE_RESPONSES_API=
+
+# Structured answers: only with {{cookiecutter.agent_directory}}/response_schema.json (the JSON
+# shape of the final answer; without it the agent answers in text). auto (the
+# provider's own structured output where the model has it and its client can send
+# the schema, else a final_answer tool the model must call) | provider | tool.
+# RESPONSE_FORMAT_STRATEGY=auto
+
+# --- Judge model (evals; defaults to the agent's provider, model and key) ---
+# JUDGE_MODEL_PROVIDER=
+# JUDGE_MODEL_NAME={{cookiecutter.default_judge_model}}
+# JUDGE_BASE_URL=
+# JUDGE_API_KEY=
+# Unset: the agent's, when the judge is an OpenAI-API model too.
+# JUDGE_REASONING_EFFORT=
+# JUDGE_USE_RESPONSES_API=
+
+# --- Persistence -------------------------------------------------------------
+{% if cookiecutter.runtime == 'fastapi' -%}
+# memory | postgres. memory needs no database (state is lost on restart); the
+# chart sets postgres and supplies POSTGRES_DSN from the subchart or the Secret.
+CHECKPOINTER=memory
+# POSTGRES_DSN=postgresql://agent:agent@localhost:5432/agent
+# Connection pool per process (shared by the checkpointer and the app tables).
+# Connections are health-checked on checkout, so a database restart heals itself.
+# DB_POOL_MIN_SIZE=1
+# DB_POOL_MAX_SIZE=10
+{% else -%}
+# LangGraph Server owns persistence. `graph-agents-cli run` and `playground`
+# use `langgraph dev` (in-memory) locally; the chart sets these in the cluster.
+# DATABASE_URI=postgresql://agent:agent@localhost:5432/agent
+# REDIS_URI=redis://localhost:6379
+{% endif -%}
+
+# --- Authentication (app/app_utils/auth.py) ---------------------------------
+# shared-bearer | jwt | custom
+AUTH_POLICY={{cookiecutter.auth_policy}}
+# shared-bearer: clients send `Authorization: Bearer <API_KEY>`. Generate one:
+#   python -c "import secrets; print(secrets.token_hex(32))"
+# `graph-agents-cli login --write-env` generates it here; `graph-agents-cli
+# secrets apply` generates one per environment when neither the env file nor the
+# cluster has one (and writes it to that env file; the live key is never
+# replaced without --rotate-api-key).
+API_KEY=
+{% if cookiecutter.auth_policy == 'jwt' -%}
+# jwt: per-user principals from a verified OIDC/JWT bearer token. Outside
+# APP_ENV=dev the issuer and the audience are required and any configuration
+# problem stops startup (under dev a missing issuer or audience is only a
+# warning and a problem answers 503).
+# Keys: a JWKS URL (https outside dev unless its host is loopback), or one PEM
+# public key or certificate (escaped \n newlines accepted), not both.
+# Local runs without an identity provider: `graph-agents-cli auth dev-token --sub
+# <user>` fills AUTH_JWT_PUBLIC_KEY, AUTH_JWT_ISSUER and AUTH_JWT_AUDIENCE below
+# with a dev key (APP_ENV=dev only) and prints a token. Never deploy that key.
+AUTH_JWT_JWKS_URL=
+# AUTH_JWT_PUBLIC_KEY=
+AUTH_JWT_ISSUER=
+AUTH_JWT_AUDIENCE=
+# Accepted algorithms (never `none`; HS* only with AUTH_JWT_ALLOW_HS=true and AUTH_JWT_SECRET).
+# AUTH_JWT_ALGORITHMS=RS256,ES256
+# Shared-secret (HS256/384/512) tokens: opt in, and put a secret of at least 32
+# bytes in the Secret (the CLI adds AUTH_JWT_SECRET to the allow-list then).
+# AUTH_JWT_ALLOW_HS=false
+# AUTH_JWT_SECRET=
+# A plain-http JWKS URL outside dev, for a trusted in-cluster issuer only.
+# AUTH_JWT_JWKS_ALLOW_HTTP=false
+# Claim holding the principal id, and the claim (dotted path allowed, e.g.
+# realm_access.roles) holding the roles.
+# AUTH_JWT_PRINCIPAL_CLAIM=sub
+# AUTH_JWT_ROLES_CLAIM=roles
+# AUTH_JWT_LEEWAY_S=60
+# AUTH_JWT_JWKS_CACHE_S=300
+# Agents calling for a user: a token carrying the RFC 8693 actor claim (`act`) is
+# the user's (its `sub`) presented by that agent. Empty turns this off (every
+# token is the user's own, as in 0.2).
+# AUTH_JWT_ACTOR_CLAIM=act
+# The client claim (`azp`; `client_id` when absent; Okta uses `cid`), and the
+# clients people sign in with: when set, a token with no `act` from any other
+# client is treated as that client presenting the user's token (`client:<azp>`).
+# AUTH_JWT_CLIENT_CLAIM=azp
+# AUTH_JWT_DIRECT_CLIENTS=
+{% else -%}
+# jwt (AUTH_POLICY=jwt): AUTH_JWT_JWKS_URL or AUTH_JWT_PUBLIC_KEY, AUTH_JWT_ISSUER,
+# AUTH_JWT_AUDIENCE; see the project README.
+{% endif -%}
+# Comma-separated roles allowed to read other principals' threads (and list,
+# never decide, their approvals).
+AUTH_READ_ACROSS_ROLES=
+# Comma-separated roles allowed to manage assistants, crons and the store under
+# langgraph-server (empty = nobody).
+AUTH_ADMIN_ROLES=
+# Agents that may call this one for a user (the actor ids, comma-separated; * for
+# any). Empty refuses every delegated request (403) until the agent is listed.
+AUTH_ALLOWED_ACTORS=
+# Roles a delegated request keeps (empty: an agent acting for a user holds none of
+# the user's roles), and how many agents may stand between the user and this one.
+# AUTH_DELEGATED_ROLES=
+# AUTH_MAX_DELEGATION_DEPTH=3
+# When an agent asks for a user, require_user_mentioned needs the record id in the
+# user's own words that agent forwarded (origin), always refuses (refuse), or counts
+# the agent's request as the user's words (request, the 0.2 behaviour: an opt-out).
+# A2A_DELEGATED_MENTIONS=origin
+# Tell the model, in one system note, that an agent wrote the request (off: fence only).
+# A2A_CALLER_NOTE=on
+# Calling other agents (A2A peers, `graph-agents-cli peer add`): send them the user's
+# own words when their card reads them (off: never), at most this many characters
+# (also the most read from an agent calling this one), how long a peer's checked
+# agent card is reused, and the most of a peer's reply the model reads.
+# A2A_FORWARD_ORIGIN=auto
+# A2A_ORIGIN_MAX_CHARS=4000
+# A2A_CARD_TTL_S=300
+# A2A_REPLY_MAX_CHARS=6000
+# langgraph-server runtime with LANGGRAPH_SERVER_URL set: the request headers
+# passed on to the server's auth handler (the headers your policy reads).
+# Empty forwards nothing.
+# AUTH_FORWARD_HEADERS=authorization,cookie
+
+# --- Outbound APIs (app/app_utils/api_client.py, api-policy.yaml) ----------
+{% if cookiecutter.has_api_policy -%}
+{% for api in cookiecutter.apis -%}
+# {{ api.name }} (auth: {{ api.auth }})
+{{ api.base_url_env }}=http://localhost:9000
+{% if api.auth == 'bearer' -%}
+{{ api.token_env }}=
+{% endif -%}
+{% endfor -%}
+{% if cookiecutter.apis | selectattr('auth', 'equalto', 'exchange') | list -%}
+# Token exchange (RFC 8693) for the auth: exchange APIs: the issuer's token endpoint
+# and this agent's client there. Put the client secret in .env (it is in secrets.keys).
+# Optional: client authentication (or client_secret_post), the subject token type
+# sent, the exchange's deadline, how long an exchanged token is reused (at most
+# 300 s), how long a refusal or a failing issuer is left alone, tokens kept per
+# process, and a plain-http token URL outside dev (a trusted in-cluster issuer only).
+# TOKEN_EXCHANGE_CLIENT_AUTH=client_secret_basic
+# TOKEN_EXCHANGE_SUBJECT_TOKEN_TYPE=urn:ietf:params:oauth:token-type:access_token
+# TOKEN_EXCHANGE_TIMEOUT_MS=2000
+# TOKEN_EXCHANGE_MAX_TTL_S=300
+# TOKEN_EXCHANGE_FAILURE_TTL_S=10
+# TOKEN_EXCHANGE_CACHE_MAX=10000
+# TOKEN_EXCHANGE_ALLOW_HTTP=false
+# TOKEN_EXCHANGE_CLIENT_SECRET=
+TOKEN_EXCHANGE_URL=
+TOKEN_EXCHANGE_CLIENT_ID=
+{% endif -%}
+{% else -%}
+# No api-policy.yaml is declared, so every outbound API call is refused. Declare
+# the APIs tools may call with `graph-agents-cli api add` (see README.md).
+{% endif -%}
+# Path of the policy file; defaults to ./api-policy.yaml.
+# API_POLICY_PATH=api-policy.yaml
+# Human approval: an API's `approval` block in api-policy.yaml holds the calls it
+# gates until a person approves them (nothing to set here). Approvals live in the
+# app's database ({% if cookiecutter.runtime == 'langgraph-server' %}table agent_approvals in DATABASE_URI{% else %}table approvals under CHECKPOINTER=postgres{% endif %};
+# in process memory otherwise) and expire after the policy's timeout_s.
+# `role:<name>` approvers need a per-user AUTH_POLICY (jwt or custom): under
+# shared-bearer every caller is the one principal `shared`, the requester itself.
+
+# --- Run guardrails and request limits (app/app_utils/limits.py) ------------
+# A value that does not parse stops the app at startup. Defaults shown.
+# Wall-clock limit of one run, in seconds; the run is cancelled (status timeout).
+# RUN_TIMEOUT_S=300
+# Per model request: timeout in seconds (0 = the provider SDK default) and retries.
+# MODEL_TIMEOUT_S=60
+# MODEL_MAX_RETRIES=2
+# Graph steps per run: two to answer, plus two per tool call made after the
+# previous one returned (50 fits 24 sequential calls). A run that reaches it
+# ends with a reply saying so (message.end status step_limit).
+# RECURSION_LIMIT=50
+# Request body cap in bytes (413 above it) and /chat metadata caps (422 above
+# them: at most N keys; keys and string values at most N characters).
+# MAX_REQUEST_BYTES=1048576
+# MAX_METADATA_KEYS=16
+# MAX_METADATA_VALUE_CHARS=256
+# Longest user message, in characters, on /chat (422 above it) and A2A (an
+# invalid-params error): one cap for every surface that reaches the model.
+# MAX_MESSAGE_CHARS=32000
+# Seconds without an event before the SSE stream sends a ": keep-alive" comment.
+# SSE_HEARTBEAT_S=15
+# Delete threads (checkpoints and run records) idle for more than N days,
+# checked hourly by every replica (best effort). 0 keeps everything.
+# RETENTION_DAYS=0
+
+# --- Logging, metrics and CORS -----------------------------------------------
+# DEBUG | INFO | WARNING | ERROR | CRITICAL
+# LOG_LEVEL=INFO
+# json | text (default: text under APP_ENV=dev, json otherwise). Records carry
+# the request id (X-Request-ID), run id, thread id and hashed principal. Access
+# lines keep the path without its query string; outbound API calls are logged
+# by API, method, operation id and path template (httpx's own URL lines are
+# off); Python warnings become records too. LOG_LEVEL=DEBUG also turns on
+# third-party debug logs, which can hold message content: use it locally.
+# LOG_FORMAT=json
+# GET /metrics serves Prometheus text; unauthenticated like /health and /ready
+# unless METRICS_TOKEN is set, so keep it off the public ingress either way.
+# METRICS_ENABLED=true
+# Optional secret: when set, GET /metrics answers only requests that send
+# `Authorization: Bearer <METRICS_TOKEN>` (configure your scraper with it{% if cookiecutter.deployment_target == 'kubernetes' %}:
+# the chart's ServiceMonitor sends it with metrics.serviceMonitor.bearerToken.enabled{% endif %});
+# /health and /ready stay open for the probes. Generate one:
+#   python -c "import secrets; print(secrets.token_hex(32))"
+# METRICS_TOKEN=
+# Optional secret: when set, the hashed principal id in logs, traces and run
+# records is HMAC-SHA256(PRINCIPAL_HASH_SALT, id) instead of a plain sha256, so
+# nobody holding them can confirm a guessed id (an email address, say) by
+# hashing it. Keep it stable: changing it changes every hash, and new ones
+# no longer match older logs and run records.
+# PRINCIPAL_HASH_SALT=
+# Comma-separated browser origins allowed to call the API; empty = no CORS.
+# (LangGraph Server reads the same variable: `langgraph dev` allows every
+# origin while it is unset; the server image starts with none.)
+# CORS_ALLOW_ORIGINS=https://app.example.com
+
+# --- Tracing (off unless TRACING_ENABLED=true) ------------------------------
+TRACING_ENABLED=false
+# metadata: structure, timing, token counts, tool names, error types, hashed
+#           principal id; no prompt/completion text, tool args/results, messages,
+#           or the client's /chat metadata.
+# full:     everything, including prompts, completions, tool I/O, error messages
+#           and the client's /chat metadata (under client_metadata).
+#           Sending full content to a hosted destination is an egress decision.
+TRACE_CAPTURE=metadata
+# With LANGSMITH_API_KEY set, traces go to LangSmith; otherwise to OTLP.
+# LANGSMITH_API_KEY=
+LANGSMITH_PROJECT={{cookiecutter.project_name}}
+# LANGSMITH_ENDPOINT=https://api.smith.langchain.com
+# OTLP/HTTP collector, used when TRACING_ENABLED=true and no LangSmith key is set.
+# OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
+# Correlation across agents (peers, the default): every call of another agent
+# (`protocol: a2a`, whatever its auth) or of an `auth: forward` or
+# `auth: exchange` API carries this request's X-Request-ID and, under OTLP
+# tracing, its W3C trace context (traceparent, tracestate); other APIs never
+# receive them. An incoming traceparent continues the caller's trace on the A2A
+# routes (/a2a/...) only. all: every API, and every path (behind a tracing
+# gateway). off (or false): neither. true reads as peers.
+# PROPAGATE_TRACE_HEADERS=peers
+
+# --- A2A ---------------------------------------------------------------------
+# Public base URL advertised in the agent card (defaults to http://HOST:PORT).
+# APP_URL=http://localhost:8000
+# What the agent card (and its chat skill) says the agent does, and the
+# version it advertises (AGENT_VERSION is also the OpenAPI and trace version).
+# A2A_DESCRIPTION=Answers questions about orders and their delivery status.
+# AGENT_VERSION=0.1.0
+# A2A tasks live in the app's database ({% if cookiecutter.runtime == 'langgraph-server' %}table agent_a2a_tasks in DATABASE_URI{% else %}table a2a_tasks under CHECKPOINTER=postgres{% endif %}:
+# every replica sees them, restarts keep them; in process memory otherwise) and
+# are dropped this many seconds after their last update (0: when their thread
+# is deleted; in memory, at restart).
+# A2A_TASK_TTL_S=3600
+
+# --- Client side (not read by the app) ---------------------------------------
+# `graph-agents-cli run --url ...` and `eval generate --url ...` send this as the
+# bearer key when --header is not given.
+# GRAPH_AGENTS_CLI_API_KEY=

graph_agents_cli/scaffold/agents/langgraph/.template/templateconfig.yaml

@@ -0,0 +1,28 @@
+# Copyright 2026 Google LLC
+# Modifications Copyright 2026 graph-agents-cli contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Read by the CLI when the template is selected; never copied into the
+# generated project, because the overlay skips .template/.
+name: "langgraph"
+description: "LangGraph ReAct agent served over a chat SSE API and A2A, with a FastAPI or LangGraph Server runtime, Postgres persistence, and a Helm chart"
+# empty_py leaves out any agent layer, so this template supplies its own
+# agent, server, tests, dependency locks and deployment files.
+base_template: "empty_py"
+example_question: "What's the weather in San Francisco?"
+settings:
+  language: "python"
+  deployment_targets: ["kubernetes", "none"]
+  agent_directory: "app"
+  tags: ["langgraph", "a2a"]

graph_agents_cli/scaffold/agents/langgraph/Dockerfile

@@ -0,0 +1,59 @@
+# FastAPI runtime image (base: the official python:3.12-slim line, pinned to an
+# exact release). Two stages: the builder installs the dependencies from the
+# committed uv.lock with a pinned uv; the final image holds only the
+# virtualenv and the app (no uv), runs as uid/gid 1000 and writes nothing
+# outside /tmp, so it runs with a read-only root filesystem.
+#
+# The tags below are exact releases. For fully reproducible builds pin them by
+# digest as well, e.g. `python:3.12.14-slim-bookworm@sha256:<digest>`
+# (`docker buildx imagetools inspect <image>` prints the digest); bump them
+# deliberately, e.g. for security updates of the base image.
+ARG PYTHON_IMAGE=python:3.12.14-slim-bookworm
+ARG UV_IMAGE=ghcr.io/astral-sh/uv:0.12.18
+
+FROM ${UV_IMAGE} AS uv
+
+FROM ${PYTHON_IMAGE} AS builder
+
+ENV UV_COMPILE_BYTECODE=1 \
+    UV_LINK_MODE=copy \
+    UV_PYTHON_DOWNLOADS=never
+
+WORKDIR /app
+
+# Dependencies first so the layer is cached until the lock changes.
+COPY pyproject.toml uv.lock ./
+RUN --mount=from=uv,source=/uv,target=/bin/uv \
+    --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-dev --no-install-project
+
+COPY {{cookiecutter.agent_directory}} ./{{cookiecutter.agent_directory}}
+RUN --mount=from=uv,source=/uv,target=/bin/uv \
+    --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-dev \
+ && python -m compileall -q {{cookiecutter.agent_directory}}
+
+FROM ${PYTHON_IMAGE}
+
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    HOME=/tmp \
+    PATH="/app/.venv/bin:$PATH" \
+    HOST=0.0.0.0 \
+    PORT=8000
+
+WORKDIR /app
+COPY --from=builder /app /app
+
+# The outbound API policy travels with the image: without it the API client
+# refuses every call. The glob copies api-policy.yaml when the project has one
+# and nothing otherwise (pyproject.toml is repeated only so the COPY always has
+# a source). --chmod makes it readable by uid 1000 whatever its mode in the
+# working tree (an unreadable policy also refuses every call).
+COPY --chmod=0644 pyproject.toml api-policy.yam[l] ./
+
+USER 1000:1000
+
+EXPOSE 8000
+
+CMD ["sh", "-c", "exec uvicorn {{cookiecutter.agent_directory}}.fast_api_app:app --host ${HOST:-0.0.0.0} --port ${PORT:-8000}"]

graph_agents_cli/scaffold/agents/langgraph/Dockerfile.langgraph-server

@@ -0,0 +1,59 @@
+# LangGraph Server runtime image. Mirrors the shape of `langgraph dockerfile`
+# output, with two differences: the dependencies are installed at the exact
+# versions of uv.lock (not resolved again), and the server runs as uid/gid 1000.
+#
+# The base image is pinned to the langgraph-api release in uv.lock
+# (langchain/langgraph-api:<version>-py3.12): bump both together. For fully
+# reproducible builds pin it by digest as well
+# (`...:0.14.4-py3.12@sha256:<digest>`; `docker buildx imagetools inspect
+# <image>` prints it). Mirror it for a disconnected registry and change the
+# FROM line accordingly.
+FROM langchain/langgraph-api:0.14.4-py3.12
+
+# The whole project (minus .dockerignore) is the dependency, so api-policy.yaml,
+# the outbound API policy the API client enforces, is in the image when the
+# project has one (made readable by uid 1000 below, whatever its mode in the
+# working tree: an unreadable policy refuses every call).
+ADD . /deps/{{cookiecutter.project_name}}
+
+# `uv export` writes the locked versions (with hashes); they are installed
+# without resolving again, and must agree with the base image's constraints, so
+# a lock that conflicts with the server fails the build instead of the server.
+# The lock must also pin the base image's own langgraph-api release (the build
+# stops with the tag to use otherwise). The base image ships uv; nothing is
+# added to it.
+RUN cd /deps/{{cookiecutter.project_name}} \
+ && if [ -f api-policy.yaml ]; then chmod a+r api-policy.yaml; fi \
+ && base_api="$(python -c "import importlib.metadata as m; print(m.version('langgraph-api'))")" \
+ && uv export --quiet --frozen --no-dev --no-emit-project --no-header -o /tmp/requirements.txt \
+ && uv pip install --system --no-cache --compile-bytecode --no-deps \
+      -c /api/constraints.txt -r /tmp/requirements.txt \
+ && uv pip install --system --no-cache --compile-bytecode --no-deps \
+      -e /deps/{{cookiecutter.project_name}} \
+ && rm /tmp/requirements.txt \
+ && lock_api="$(python -c "import importlib.metadata as m; print(m.version('langgraph-api'))")" \
+ && if [ "$base_api" != "$lock_api" ]; then \
+      echo "uv.lock pins langgraph-api $lock_api but the base image is $base_api:" \
+           "use FROM langchain/langgraph-api:$lock_api-py3.12" >&2; \
+      exit 1; \
+    fi
+
+# The graph, the custom routes (/chat, /threads, /health, /ready, /metrics,
+# /playground, A2A) and the auth handler, as langgraph.json declares them.
+# `disable_meta` turns off the server's unauthenticated meta routes (/docs,
+# /openapi.json, /info, /metrics); the app's own /metrics takes over.
+ENV LANGSERVE_GRAPHS='{"agent": "/deps/{{cookiecutter.project_name}}/{{cookiecutter.agent_directory}}/agent.py:graph"}'
+ENV LANGGRAPH_HTTP='{"app": "/deps/{{cookiecutter.project_name}}/{{cookiecutter.agent_directory}}/fast_api_app.py:app", "disable_meta": true}'
+ENV LANGGRAPH_AUTH='{"path": "/deps/{{cookiecutter.project_name}}/{{cookiecutter.agent_directory}}/app_utils/auth.py:auth"}'
+# LANGGRAPH_SERVER tells fast_api_app.py it is mounted inside the server (no
+# checkpointer binding). The server allows every CORS origin when
+# CORS_ALLOW_ORIGINS is unset; the image starts from none, like the fastapi
+# runtime: list your browser origins in CORS_ALLOW_ORIGINS (comma-separated).
+ENV LANGGRAPH_SERVER=1 \
+    CORS_ALLOW_ORIGINS="" \
+    PYTHONDONTWRITEBYTECODE=1 \
+    HOME=/tmp
+
+WORKDIR /deps/{{cookiecutter.project_name}}
+
+USER 1000:1000