# Angular

> Connect an Angular app to Copilot Runtime with CopilotKit.

This guide takes an Angular app to a working chat UI backed by [Copilot Runtime](/angular/langgraph-typescript/backend/copilot-runtime). When you select an agent backend in the sidebar, the backend step below changes with it. Without a selection, the guide uses CopilotKit's `BuiltInAgent`.

The runtime runs on your server, keeps model credentials out of the browser, and exposes the `default` agent that `CopilotChat` uses automatically.

<OpsPlatformCTA
  variant="inline"
  title="Take your Angular copilot from local to production"
  body="Add threads, inspection, and cloud-hosted or self-hosted CopilotKit Intelligence without changing the Angular frontend APIs in this guide."
  surface="docs:angular/quickstart:production"
/>

## Start with your coding agent [#start-with-your-coding-agent]

Use this prompt to connect your Angular app to Copilot Runtime with the selected agent backend, then verify a working conversation. You can also follow the manual steps below.

<PageAgentPrompt />

## Prerequisites [#prerequisites]

- An OpenAI API key (or another model provider supported by [Model Selection](/model-selection))
- Angular 22
- Node.js 22

## Getting started [#getting-started]

<Steps>
    <Step>
        ### Create your Angular app [#create-your-angular-app]

        If you don't have one already, pin the CLI to the supported major:

        ```bash
        npx @angular/cli@22 new my-copilot-app
        cd my-copilot-app
        ```
    </Step>
    <Step>
        ### Install CopilotKit [#install-copilotkit]

        `@copilotkit/angular` gives you Angular components, directives, and services for CopilotKit. It supports zoneless applications. Install it with `@angular/cdk`, and install `@copilotkit/runtime` for your local Copilot Runtime server:

        <Tabs groupId="package-manager" items={['npm', 'pnpm', 'yarn']}>
            <Tab value="npm">
                ```bash
                npm install @copilotkit/angular @angular/cdk @copilotkit/runtime
                npm install -D tsx typescript @types/node
                ```
            </Tab>
            <Tab value="pnpm">
                ```bash
                pnpm add @copilotkit/angular @angular/cdk @copilotkit/runtime
                pnpm add -D tsx typescript @types/node
                ```
            </Tab>
            <Tab value="yarn">
                ```bash
                yarn add @copilotkit/angular @angular/cdk @copilotkit/runtime
                yarn add -D tsx typescript @types/node
                ```
            </Tab>
        </Tabs>

        <Callout type="info" title="Match @angular/cdk to your Angular version">
          `@angular/cdk` must share your Angular major version. Most package managers resolve this for you, but if you hit a peer-dependency error, pin it explicitly (for example `@angular/cdk@^22`).
        </Callout>
    </Step>
    <Step>
      ### Connect the selected agent backend [#connect-the-selected-agent-backend]

      First, extend your graph's state annotation with `CopilotKitStateAnnotation`
      and bind forwarded actions through `convertActionsToDynamicStructuredTools`.
      The annotation is what makes every CopilotKit feature on the frontend —
      frontend tools, shared state, agent context, and generative UI components —
      visible to your LangGraph agent on every turn.

      ~~~~typescript title="frontend-tools.ts"
      import type { RunnableConfig } from "@langchain/core/runnables";
      import { SystemMessage } from "@langchain/core/messages";
      import { MemorySaver, START, StateGraph } from "@langchain/langgraph";
      import { ChatOpenAI } from "@langchain/openai";
      import {
        convertActionsToDynamicStructuredTools,
        CopilotKitStateAnnotation,
      } from "@copilotkit/sdk-js/langgraph";

      // CopilotKit forwards frontend tools to the agent via
      // `state.copilotkit.actions`. `CopilotKitStateAnnotation` adds that
      // channel to your graph's state; `convertActionsToDynamicStructuredTools`
      // turns the forwarded action schemas into LangChain tools you can bind
      // at model-invocation time.
      const AgentStateAnnotation = CopilotKitStateAnnotation;
      export type AgentState = typeof AgentStateAnnotation.State;

      const SYSTEM_PROMPT = "You are a helpful, concise assistant.";

      async function runChatNode(
        state: AgentState,
        config: RunnableConfig,
        model: ChatOpenAI,
      ) {
        const modelWithTools = model.bindTools!([
          ...convertActionsToDynamicStructuredTools(state.copilotkit?.actions ?? []),
        ]);

        const response = await modelWithTools.invoke(
          [new SystemMessage({ content: SYSTEM_PROMPT }), ...state.messages],
          config,
        );

        return { messages: response };
      }

      async function chatNode(state: AgentState, config: RunnableConfig) {
        return runChatNode(
          state,
          config,
          new ChatOpenAI({
            modelKwargs: { reasoning_effort: "none" },
            temperature: 0,
            model: "gpt-6-luna",
          }),
        );
      }

      function compileGraph(node: typeof chatNode) {
        return new StateGraph(AgentStateAnnotation)
          .addNode("chat_node", node)
          .addEdge(START, "chat_node")
          .addEdge("chat_node", "__end__")
          .compile({ checkpointer: new MemorySaver() });
      }

      export const graph = compileGraph(chatNode);
      ~~~~

      <Accordions>
        <Accordion title="Install the SDK">
          If `@copilotkit/sdk-js` isn't already in your project, add it so the
          imports above resolve:

          ```bash
          npm install @copilotkit/sdk-js
          ```

        </Accordion>
      </Accordions>

      <Callout type="info" title="Expose the selected backend through Copilot Runtime">
        Configure Copilot Runtime to register this backend as the `default`
        agent at `/api/copilotkit`. Continue with the selected backend's
        [Copilot Runtime guide](/angular/langgraph-typescript/backend/copilot-runtime) for its runtime
        adapter, credentials, and server command. Do not replace it with the
        `BuiltInAgent` server from the standalone Angular path.
      </Callout>
    </Step>
    <Step>
        ### Import the styles [#import-the-styles]

        Add the package stylesheet to your global styles. It's self-contained, so the chat renders without any other CSS.

        ```css title="src/styles.css"
        @import "@copilotkit/angular/styles.css"; /* [!code highlight] */
        ```
    </Step>
    <Step>
        ### Connect to Copilot Runtime [#connect-to-copilot-runtime]

        Point `provideCopilotKit` at the runtime endpoint. The chat uses the agent that your runtime registers as `default`.

        ```ts title="src/app/app.config.ts"
        import { ApplicationConfig } from "@angular/core";
        import { provideCopilotKit } from "@copilotkit/angular"; // [!code highlight]

        export const appConfig: ApplicationConfig = {
          providers: [
            // [!code highlight:3]
            provideCopilotKit({
              runtimeUrl: "http://localhost:8200/api/copilotkit",
            }),
          ],
        };
        ```
    </Step>
    <Step>
        ### Add the chat UI [#add-the-chat-ui]

        Import the `CopilotChat` component into your root component and drop it into the template.

        ```ts title="src/app/app.ts"
        import { Component } from "@angular/core";
        import { CopilotChat } from "@copilotkit/angular"; // [!code highlight]

        @Component({
          selector: "app-root",
          imports: [CopilotChat], // [!code highlight]
          template: `
            <!-- [!code highlight:3] -->
            <div style="height: 100vh">
              <copilot-chat />
            </div>
          `,
        })
        export class App {}
        ```

    </Step>
    <Step>
      ### Run the backend, runtime, and Angular app [#run-the-backend-runtime-and-angular-app]

      Start the selected agent backend and Copilot Runtime with the commands
      from its runtime guide. Confirm
      `http://localhost:8200/api/copilotkit/info` reports the `default`
      agent, then start Angular:

      ```bash
      npm start
      ```

      Open the Angular CLI URL (usually `http://localhost:4200`) and send a
      message. The request now follows the selected path end to end:
      Angular → Copilot Runtime → your selected agent backend.
    </Step>
    <Step>
        ### Open Inspector and confirm setup [#open-inspector-and-confirm-setup]

        On localhost, click the Inspector button in the corner of the app.

        1. Open **Inspect**, then **Agent**. Your agent is listed.
        2. Send a chat message. Open **Inspect**, then **AG-UI Events**. Events are moving.
        3. Open **Rich Threads**. The list is unlocked (Intelligence is on), or locked with **Copy setup prompt** (Intelligence is off).

        More detail: [Inspector](/angular/langgraph-typescript/inspector).
    </Step>

</Steps>

## Next steps [#next-steps]

1. [Prebuilt Components](/angular/prebuilt-components): choose a chat surface, then follow the sidebar to frontend tools, generative UI, human-in-the-loop, shared state, threads, attachments, and headless UI.
2. [Runtime and backend docs](/angular/langgraph-typescript/backend/copilot-runtime): configure the server, secure requests, and deploy without leaving the selected Angular surface.

Later:

- [CopilotKit Intelligence](/angular/langgraph-typescript/intelligence/overview): add threads, inspection, and cloud-hosted or self-hosted operations.
- [Angular API reference](/reference/angular): use components, signals, tools, context, and runtime services.
- [Production and lifecycle](/reference/angular/production-lifecycle): handle cleanup, errors, server rendering, hydration, zoneless Angular, and browser-only features.
