Multi-language agent SDK — two IR compilers shipping

java -jar langstitch-spring-ai-0.2.0-all.jar \
  compile my_graph.langstitch.json --out my_graph-spring --force

cd my_graph-spring
mvn -q test
mvn -q spring-boot:run

langstitch-spring-ai compile <document.langstitch.json> --out <dir> [--force]
langstitch-spring-ai capabilities
langstitch-spring-ai version

<dependency>
  <groupId>com.langstitch</groupId>
  <artifactId>langstitch-spring-ai</artifactId>
  <version>0.2.0</version>
</dependency>

application.yaml          # includes mcp.servers when IR has mcpServers
env.yaml
pom.xml
.langstitch-build-manifest.json
src/main/java/com/langstitch/<pkg>/
  Application.java
  GraphState.java
  graph/MainGraph.java
  nodes/*.java
  mcp/McpToolClient.java   # when logical.mcpServers is present
  config/AiConfig.java
  web/GraphController.java
src/main/resources/application.yml

langstitch new my-agent      # scaffold
cd my-agent
python -m venv .venv && . .venv/bin/activate   # (Windows: .venv\Scripts\activate)
pip install -e .             # editable install (add extras as needed)
python -m app                # bootstrap + print registered components (JSON)
pytest -q                    # run the generated smoke tests
langstitch run               # start the API server

curl -s localhost:8000/info | python -m json.tool
curl -s -X POST localhost:8000/invoke \
  -H 'content-type: application/json' \
  -d '{"messages": [{"role": "user", "content": "hi"}]}'

from langstitch import skill

@skill
def echo(text: str) -> str:
    return text

@skill(name="search", tools=["web"], tags=["retrieval"])
def web_search(query: str) -> list[str]:
    ...

from langstitch import LangStitchApp

app = LangStitchApp.bootstrap()
graph = app.build_graph()           # compiles to a LangGraph StateGraph
result = app.invoke({"messages": [{"role": "user", "content": "hi"}]})
print(result)

my-agent/
  application.yaml     # application config (or precompiled application.json)
  env.yaml             # runtime environment variables (gitignored in real projects)
  pyproject.toml       # depends on langstitch; your package is "app"
  app/
    __init__.py        # imports submodules so decorators register on import
    graphs/            # @graph — main graph (main.py) + subgraphs
    nodes/             # @graph_node — node handlers (state -> dict)
    skills/            # @skill
    guardrails/        # @input_guardrail / @output_guardrail
    policies/          # @business_policy
    personas/          # @persona
    tools/             # @tool
    agents/            # @worker_agent
    mcp/               # @langstitch_mcp_server + @mcp_tool/resource/prompt
    config.py          # @configuration — typed application.yaml sections
    state.py           # graph state schema (TypedDict)
    main.py            # @langstitch_graph_server — server + bootstrap()
  tests/               # smoke tests

# app/__init__.py
from . import graphs, nodes, skills, guardrails, policies
from . import personas, tools, agents, mcp, config

from langstitch import (
    graph, graph_node, skill, persona,
    input_guardrail, business_policy,
    tool, langstitch_graph_server, GraphBuilder, END,
)

@persona(role="assistant", tone="helpful, concise")
def assistant() -> str:
    return "You are a helpful LangStitch support assistant."

@tool(tags=["billing"], roles=["agent"])
def lookup_invoice(invoice_id: str) -> dict:
    """Fetch an invoice by id."""
    ...

@input_guardrail(description="Reject empty/oversized input.", action="block")
def non_empty(text: str) -> bool:
    return bool(text and 0 < len(text) <= 8000)

@business_policy(priority=100, description="Deny refunds over policy limit.")
def refund_limit(context: dict) -> dict:
    amount = context.get("amount", 0)
    return {"decision": "deny" if amount > 1000 else "allow"}

@graph_node(description="Answer the latest message.")
def respond(state: dict) -> dict:
    return {"response": "...", "messages": [...]}

@graph(name="main", entrypoint=True)
def main_graph() -> GraphBuilder:
    g = GraphBuilder("main")
    g.add_node("respond", respond)
    g.set_entry_point("respond")
    g.add_edge("respond", END)
    return g

@langstitch_graph_server(name="my-agent", protocol="http", port=8000)
class Server:
    """Graph API server."""

from langstitch import load_config, get_config

cfg = load_config()          # loads env.yaml then application config
get_config("server.port")    # -> 8000
get_config("model")          # -> {...}
get_config("missing.key", default="fallback")
get_config("server", as_json=True)

# CLI equivalents:
# langstitch get server.port
# langstitch get external_services.billing.auth.type

from dataclasses import dataclass
from langstitch import configuration

@configuration(section="server")
@dataclass
class ServerConfig:
    host: str = "0.0.0.0"
    port: int = 8000

from langstitch import graph, graph_node, GraphBuilder, END

@graph_node
def respond(state: dict) -> dict:
    return {"response": "hello"}

@graph(name="main", entrypoint=True)
def main_graph() -> GraphBuilder:
    g = GraphBuilder("main")
    g.add_node("respond", respond)
    g.set_entry_point("respond")
    g.add_edge("respond", END)
    return g

from langstitch import agent, remote_agent, run_agent

@agent(tools=["web"], roles=["analyst"])
def researcher(state: dict) -> dict:
    return {"findings": "..."}

# Remote graph (HTTP /invoke) — auth via an external_services entry:
remote_agent("legal", url="/invoke", service="legal_svc", roles=["counsel"])

# A2A peer — url is the Agent Card:
agent(name="billing", transport="a2a",
      url="https://billing/.well-known/agent.json", service="billing_a2a")

out = run_agent({"input": "review contract"}, "legal", caller_roles=["counsel"])

from langstitch import supervisor, get_supervisor

@supervisor(agents=["researcher", "legal"], router="custom")
def triage(state) -> str:
    return "legal" if state.get("contract") else "researcher"

team = get_supervisor("triage").build()
graph = team.compile()   # needs the graph extra

from langstitch import graph_node, handoff, make_handoff_tool

@graph_node
def intake(state):
    return handoff("billing", update={"reason": "refund"})

transfer = make_handoff_tool("legal")   # LLM-invokable handoff tool

from langstitch import langstitch_a2a_server, a2a_skill

@langstitch_a2a_server(title="Billing Agent", url="https://billing.acme.com/")
class BillingAgent:
    ...

@a2a_skill(skill_id="refund", roles=["billing"], tags=["payments"])
def refund(state: dict) -> dict:
    caller = state["a2a_identity"]["subject"]
    return {"output": f"refund processed for {caller}"}

from langstitch import a2a_agent, a2a_client, invoke_a2a_agent

a2a_agent("orders",
          agent_card_url="https://orders.acme.com/.well-known/agent.json",
          service="orders_a2a", roles=["billing"])

result = invoke_a2a_agent("create order #42", agent="orders", skill_id="create")

with a2a_client("orders") as client:
    reply = client.send_message("status of #42", skill_id="status")

from langstitch import human_interrupt, graph_node

@graph_node
def review(state: dict) -> dict:
    decision = human_interrupt({"question": "Approve?", "draft": state["draft"]})
    return {"approved": decision == "yes"}

# application.yaml
tracing:
  enabled: true
  project: my-agent-project
  log_format: json          # text | json
  register_on_build: true   # upsert LangSmith project on build_graph()
  trace_nodes: true

from langstitch import LangStitchApp, configure_tracing, register_graph

configure_tracing()
app = LangStitchApp.bootstrap()
app.build_graph()   # registers entrypoint when tracing.register_on_build is true

langstitch register                # register entrypoint graph
langstitch register --describe-only   # metadata only, no LangGraph compile

external_services:
  billing:
    serverUrl: https://billing.internal
    basePath: /v1
    timeout: 30
    propagate_headers: [x-request-id]
    auth:
      type: bearer
      token: ${BILLING_TOKEN}

from langstitch import get_http_client

client = get_http_client("billing")
resp = client.get("/invoices/42")

from langstitch import input_guardrail, business_policy, persona

@input_guardrail(description="Reject empty input.", action="block")
def non_empty(text: str) -> bool:
    return bool(text and len(text) <= 8000)

@business_policy(priority=100, description="Refund limit.")
def refund_limit(context: dict) -> dict:
    return {"decision": "deny" if context.get("amount", 0) > 1000 else "allow"}

@persona(role="assistant", tone="helpful, concise")
def assistant() -> str:
    return "You are a helpful assistant."

from langstitch import (
    langstitch_mcp_server, mcp_tool, mcp_resource, mcp_prompt,
)

@langstitch_mcp_server(protocol="stdio")
class MyServer:
    """Project MCP server."""

@mcp_tool(name="search", description="Search the knowledge base.")
def search(query: str) -> list[str]:
    ...

@mcp_resource(name="readme", uri="file:///README.md", mime_type="text/markdown")
def readme() -> str:
    ...

@mcp_prompt(name="summarize", description="Summarize a document.")
def summarize(text: str) -> str:
    ...

python -m app        # bootstrap + print every registered component as JSON
pytest -q            # run generated smoke tests
langstitch info      # load config + list components
langstitch run       # start the FastAPI server (/health, /info, /invoke)

from langstitch import LangStitchApp

app = LangStitchApp.bootstrap()
result = app.invoke({"messages": [{"role": "user", "content": "hi"}]})

export LANGSTITCH_DEV_EVENTS=1
export LANGSTITCH_API_KEY=dev
langstitch run
# GET /runs/{run_id}/events  (localhost SSE; per-run seq numbers)

FROM python:3.13-slim
WORKDIR /app
COPY . .
RUN pip install --no-cache-dir ".[server,graph,llm,http]" \
 && langstitch compile
EXPOSE 8000
CMD ["langstitch", "run", "--host", "0.0.0.0", "--port", "8000"]

langstitch new <name> [--dir PATH] [--force]   scaffold an Agentic Development project
langstitch plugin new <name> [--dir PATH] [--force]   scaffold a Plugin Creator pack project
langstitch pack [--root PATH] [--out DIR] [--document PATH] [--platforms LIST]   build a .langstitch-pack.zip (fail-closed; use --allow-partial to skip missing platforms)
langstitch validate-pack [--root PATH] [--document PATH]   validate pack manifests + IR before publish
langstitch info [--root PATH]                   load config + list components
langstitch run [--root PATH] [--host] [--port]  start the API server
langstitch register [--root PATH] [--describe-only]  LangSmith graph registration
langstitch compile [document.langstitch.json] [--out DIR] [--force]  IR v2 -> Python project (or config precompile)
langstitch get <json.path> [--root PATH]        resolve a config path, print as JSON
langstitch version                              print the SDK version

langstitch-spring-ai compile <document.langstitch.json> --out <dir> [--force]
langstitch-spring-ai capabilities
langstitch-spring-ai version

pip install langstitch-sdk
python -c "help('langstitch')"