Capstone: build Jarvis end-to-end

jarvis/
├── langgraph.json              # deployment manifest
├── pyproject.toml              # deps
├── .env                        # secrets (gitignored)
├── src/
│   ├── jarvis.py               # exports `graph` for the platform
│   ├── state.py                # JarvisState typed dict + reducers
│   ├── supervisor.py           # supervisor node + routing model
│   ├── agents/
│   │   ├── it.py
│   │   ├── hr.py
│   │   ├── calendar.py
│   │   └── knowledge.py
│   ├── tools/
│   │   ├── helpdesk.py         # open_it_ticket, ticket_status
│   │   ├── hris.py             # leave_balance, policy_lookup
│   │   ├── calendar.py         # find_room, schedule_meeting
│   │   └── kb.py               # lookup_policy (retrieval over Chroma)
│   ├── memory/
│   │   ├── load.py             # load_user_memories node
│   │   └── extract.py          # post-turn fact extractor
│   ├── guards/
│   │   ├── injection.py        # input guardrail
│   │   └── rate_limit.py       # per-user quotas
│   └── auth.py                 # JWT verification → config.configurable
├── tests/
│   ├── test_tools.py
│   ├── test_routing.py         # FakeListChatModel routing tests
│   └── eval/
│       └── run_dataset.py      # LangSmith eval runner used in CI
└── scripts/
    └── seed_kb.py              # one-time: ingest policy PDFs into Chroma

jarvis/
├── langgraph.json
├── package.json
├── tsconfig.json
├── .env
├── src/
│   ├── jarvis.ts               // exports `graph`
│   ├── state.ts                // JarvisState (Annotation.Root) + reducers
│   ├── supervisor.ts
│   ├── agents/
│   │   ├── it.ts
│   │   ├── hr.ts
│   │   ├── calendar.ts
│   │   └── knowledge.ts
│   ├── tools/
│   │   ├── helpdesk.ts
│   │   ├── hris.ts
│   │   ├── calendar.ts
│   │   └── kb.ts
│   ├── memory/
│   │   ├── load.ts
│   │   └── extract.ts
│   ├── guards/
│   │   ├── injection.ts
│   │   └── rateLimit.ts
│   └── auth.ts
├── tests/
│   ├── tools.test.ts
│   ├── routing.test.ts
│   └── eval/runDataset.ts
└── scripts/
    └── seedKb.ts

from langgraph.graph import StateGraph, START, END
from .state import JarvisState
from .memory.load import load_user_memories
from .guards.injection import injection_check
from .supervisor import supervisor_node, route_after_supervisor, SPECIALISTS

def build():
    g = StateGraph(JarvisState)

    # Pipeline nodes
    g.add_node("inject_check", injection_check)        # guardrail
    g.add_node("memories",    load_user_memories)      # load long-term facts
    g.add_node("supervisor",  supervisor_node)         # picks next worker

    # Specialist sub-agents (each itself a compiled ReAct graph)
    for name, agent in SPECIALISTS.items():
        g.add_node(name, agent)

    # Wire it
    g.add_edge(START, "inject_check")
    g.add_edge("inject_check", "memories")
    g.add_edge("memories", "supervisor")
    g.add_conditional_edges(
        "supervisor",
        route_after_supervisor,
        {**{n: n for n in SPECIALISTS}, "FINISH": END},
    )
    for name in SPECIALISTS:
        g.add_edge(name, "supervisor")                 # specialists report back

    return g

# Exported for langgraph deploy — Platform compiles with its own checkpointer/store.
graph = build()

import { StateGraph, START, END } from "@langchain/langgraph";
import { JarvisState } from "./state";
import { loadUserMemories } from "./memory/load";
import { injectionCheck } from "./guards/injection";
import { supervisorNode, routeAfterSupervisor, SPECIALISTS } from "./supervisor";

function build() {
  const g = new StateGraph(JarvisState)
    .addNode("inject_check", injectionCheck)
    .addNode("memories", loadUserMemories)
    .addNode("supervisor", supervisorNode);

  for (const [name, agent] of Object.entries(SPECIALISTS)) g.addNode(name as any, agent);

  g.addEdge(START, "inject_check")
   .addEdge("inject_check", "memories")
   .addEdge("memories", "supervisor")
   .addConditionalEdges("supervisor", routeAfterSupervisor, {
      ...Object.fromEntries(Object.keys(SPECIALISTS).map(n => [n, n])),
      FINISH: END,
   });
  for (const name of Object.keys(SPECIALISTS)) g.addEdge(name as any, "supervisor");

  return g;
}

export const graph = build();

# Local — gives you the Studio UI at http://localhost:2024
langgraph dev

# Deploy
langgraph deploy --name jarvis-prod

# Hit it from your client (Python)
from langgraph_sdk import get_client
client = get_client(url="https://...langgraph.app")
thread = await client.threads.create()
async for chunk in client.runs.stream(
    thread["thread_id"], "jarvis",
    input={"messages": [{"role":"user","content":"Printer floor 3 jammed; also lunch with Anuj tomorrow 1pm"}]},
    config={"configurable": {"user_email":"priya@acme.com", "org_id":"acme"}},
    stream_mode="updates",
):
    print(chunk.event, chunk.data)

npx @langchain/langgraph-cli dev
npx @langchain/langgraph-cli deploy --name jarvis-prod

import { Client } from "@langchain/langgraph-sdk";
const client = new Client({ apiUrl: "https://...langgraph.app" });
const thread = await client.threads.create();
for await (const chunk of client.runs.stream(thread.thread_id, "jarvis", {
  input: { messages: [{ role: "user", content: "..." }] },
  config: { configurable: { user_email: "priya@acme.com", org_id: "acme" } },
  streamMode: "updates",
})) console.log(chunk.event, chunk.data);