LangGraph, LangChain and ADK

LangGraph, LangChain and Google ADK keep the conversation on your backend. Passing cloud gives those runtimes a Cloud backed thread list, a copy of each conversation, feedback and engagement events, while the backend continues to own the messages and model execution.

The cloud creates, lists, renames, archives and deletes the conversation records users see in the app, and keeps a copy of their messages for the dashboard. It does not receive browser run reports from these runtimes, so use traces when you want the Runs and Models views to describe your backend.

What the cloud adds

The copy is observability data. telemetry: { messages: false } on the AssistantCloud client keeps it out while the thread list, events and titles continue; telemetry: false also stops events. A stored user message counts its end user toward the project's monthly active users.

Connect your backend

useLangGraphRuntime accepts cloud with three callbacks. create creates the backend conversation and returns its id as externalId. The cloud writes that value as external_id. load receives the same value when a user opens the cloud thread. delete runs before the cloud thread is deleted and receives the cloud thread id, so read the thread to find your backend id.

const runtime = useLangGraphRuntime({
  cloud,
  stream: async (messages, { initialize }) => {
    const { externalId } = await initialize();
    if (!externalId) throw new Error("Thread not found");
    return sendMessage({ threadId: externalId, messages });
  },
  create: async () => ({ externalId: (await createThread()).thread_id }),
  load: async (externalId) => ({
    messages: (await getThreadState(externalId)).values.messages ?? [],
  }),
  delete: async (cloudThreadId) => {
    const { external_id } = await cloud.threads.get(cloudThreadId);
    if (external_id) await deleteThread(external_id);
  },
});

useStreamRuntime from @assistant-ui/react-langchain and useAdkRuntime from @assistant-ui/react-google-adk use the same Cloud thread-list arrangement. When create is omitted, the runtime initializes its own thread first and that initialization supplies the external id for the cloud thread. onThreadIdChange receives the settled cloud thread id on all three runtimes.

Choose one thread-list owner

useLangGraphRuntime and useStreamRuntime from @assistant-ui/react-langchain treat unstable_threadListAdapter as the thread-list owner. When it is present, cloud, create and delete do nothing. useAdkRuntime does the same with sessionAdapter: it takes precedence, so its cloud, create and delete options are inert. Keep the Cloud adapter when you want Cloud threads, or supply one of those adapters when your application already owns the list.

Give the first thread a title

The runtime asks for a title as soon as it creates the cloud thread, with the user's message, and the cloud streams the title back as the model writes it. Nothing has to be stored in the cloud for that, so these runtimes are titled like every other one. generateTitle() on the thread list item asks again and receives the stored title. See Thread titles for the title rules and the fallback shown while a title is absent.

Fill Runs and Models with traces

Export your server's GenAI OpenTelemetry spans to POST /v1/traces. A trace becomes a run with its spans, steps, tool calls, token counts and model information. Set gen_ai.conversation.id to the Cloud thread id so the run is attached to the conversation. If that value does not name a Cloud thread, it remains an attribute on the imported run instead.

Traces are accepted with an API key, not a browser token. They are the appropriate reporting path for LangGraph, LangChain and ADK because the work happens on the server. In a Next.js app that hosts the graph, the exporter is registered once at startup:

import { registerOTel } from "@vercel/otel";
import {
  createAssistantCloudSpanProcessor,
  createAssistantCloudTraceExporter,
} from "assistant-cloud/telemetry";

export function register() {
  registerOTel({
    serviceName: "my-agent",
    spanProcessors: [
      "auto",
      createAssistantCloudSpanProcessor(
        createAssistantCloudTraceExporter({
          apiKey: process.env.ASSISTANT_API_KEY!,
        }),
      ),
    ],
  });
}

A Python graph exports the same way through the OpenTelemetry SDK's OTLP HTTP exporter, pointed at https://backend.assistant-api.com/v1/traces with the API key as the bearer header; Traces has the configuration. Run reports describes what the browser still reports on its own.

Feedback needs remote ids

The feedback adapter submits a rating only after it can resolve both ids needed by the API. It never blocks the interface or throws into it.

When both ids exist, the adapter sends positive or negative feedback for that message. See Scores for how ratings appear in the project.

Troubleshooting