vercel__eve/docs/install-integrations.mdx

---
title: "Add Integrations"
description: "Discover and install extensions and other integrations from eve and third-party sources."
contentType: "How-to"
---

Install integrations from eve's official catalog, a third-party source, or an integration URL. Integrations are distributed using the [shadcn registry format](https://ui.shadcn.com/docs/registry).

## Install an integration

Run `eve add` from an eve agent project. This installs the integration's dependencies and writes its declared files into your project.

```bash
eve add extension/agent-browser
eve add channel/linear
eve add instrumentation/braintrust
eve add memory/file
```

If an item is not found, `eve add` searches the available catalogs and prints close matches without installing anything.

Web Chat installs a project-level Next.js application. It cannot be added to an eve agent workspace; eve rejects the installation before writing files. See [Project Structure](./concepts/project-structure) for browser-app placement and [Next.js](./guides/frontend/nextjs) for manual integration.

If you do not know an item name yet, run `eve add` without an argument. Its help output shows how to search the registry with `eve registry search <query>`.

Extensions may create a mount under `agent/extensions/`. Connections write their initial definition under `agent/connections/` and install `@vercel/connect` when required. Instrumentation integrations write one destination file under `agent/instrumentation/`, so you can install and configure multiple exporters independently. Configure generated files and required environment variables before running your agent.

When an official item declares an interactive setup flow or flows, eve asks whether to run them after installation and runs multiple flows in declaration order. Run the printed `eve add <item> --skip-install` command to resume a skipped or cancelled setup later; it reruns the item's declared flows from the beginning.

For example, `eve add memory/file` can provision its required storage through the same setup flow. After **Install and set up**, eve creates or reuses a dedicated private Vercel Blob store, connects production, preview, and development with namespaced credentials, pulls the environment, and offers to deploy. The review and setup transcript show the project, store, primary function region, environments, and possible Blob usage charges before provisioning.

An official item may identify optional pnpm dependencies that have build scripts. Before installation, eve asks whether to skip those optional packages, allow their build scripts, or abort. Your choice updates `ignoredOptionalDependencies` or `allowBuilds` in the pnpm workspace that owns the project. Allow build scripts only when you trust the packages named in the prompt.

## Automate setup

Use `eve add <item> --non-interactive` when a script or coding agent cannot answer terminal prompts. It prints NDJSON events and exits with a status you can branch on:

| Exit code | Meaning                                         |
| --------- | ----------------------------------------------- |
| `0`       | Installation and setup completed.               |
| `1`       | Installation or setup failed.                   |
| `2`       | Setup needs an answer or an unmet prerequisite. |

On exit code `2`, read the final event and run its `next.command`. For a non-secret question, replace its `<JSON value>` placeholder with the answer you collected. Never pass a secret in `--answer`; use the environment variable or secret store the integration documents. Add `--yes` to accept recommended values; explicit answers take precedence.

A setup may report `eve link` as a prerequisite. Run it, then retry the continuation. See [Deployment](./guides/deployment/vercel.mdx) for the non-interactive `eve link` and `eve deploy` forms.

## Find an integration

Browse the [Integrations directory](/integrations) to see the official integrations available from the eve registry.

List every official integration and configured third-party source:

```bash
eve registry list
```

Search the catalog when you know what capability you need. Search returns up to 10 matches by default; use `--limit` to request between 1 and 100:

```bash
eve registry search browser --limit 5
```

Inspect an integration before you install it:

```bash
eve registry view extension/agent-browser
```

`list` includes the official eve catalog and every source you add to the project. `search` also includes [skills.sh](https://skills.sh), available as the built-in `@skills` source.

## Add a skill

Add a known [skills.sh](https://skills.sh) item directly:

```bash
eve add @skills/vercel-labs/agent-skills/vercel-react-best-practices
```

Skills from skills.sh are community-authored project files. Review their source and the resulting diff before you run your agent.

## Add a third-party source

Use the integration URL template provided by the registry publisher and give the source a namespace:

```bash
eve registry add @acme=https://registry.acme.com/r/{name}.json
```

eve stores the mapping in `package.json#registries`. The `{name}` placeholder becomes the integration name, so `@acme/analytics` resolves to `https://registry.acme.com/r/analytics.json`.

Limit listing or search to that registry when needed:

```bash
eve registry list --registry @acme
eve registry search analytics --registry @acme
```

Install an integration from that source:

```bash
eve add @acme/analytics
```

Install a known integration URL directly when you do not need a namespace:

```bash
eve add https://registry.acme.com/r/analytics.json
```

## Contribute an official integration

Community contributions to the official registry are welcome. Open an issue and get maintainer agreement before submitting a pull request, then follow the [registry contribution guide](https://github.com/vercel/eve/blob/main/CONTRIBUTING.md#adding-an-integration-to-the-registry) for the required source files, metadata, validation, and extension requirements.

## Host your own registry

Hosting your own registry is the publishing side of the [third-party source workflow](#add-a-third-party-source). Once it is deployed, other eve projects can give it a namespace and pull integrations from it.

An eve registry is a standard [shadcn registry](https://ui.shadcn.com/docs/registry), so it can be hosted by any service that serves JSON over HTTP. It needs two kinds of endpoint:

- A catalog such as `https://registry.acme.com/r/registry.json` for `eve registry list` and `eve registry search`
- One JSON document per integration, such as `https://registry.acme.com/r/analytics.json`, for `eve registry view` and `eve add`

Start with a source file for the integration and a `registry.json` that describes where to install it:

```text
registry.json
registry/
└── analytics.ts
```

```json title="registry.json"
{
  "$schema": "https://ui.shadcn.com/schema/registry.json",
  "name": "acme",
  "homepage": "https://registry.acme.com",
  "items": [
    {
      "name": "analytics",
      "type": "registry:item",
      "title": "Acme Analytics",
      "description": "Add Acme analytics tools to an eve agent.",
      "dependencies": ["@acme/eve-analytics"],
      "envVars": {
        "ACME_API_KEY": ""
      },
      "files": [
        {
          "path": "registry/analytics.ts",
          "type": "registry:file",
          "target": "agent/extensions/analytics.ts"
        }
      ]
    }
  ]
}
```

`files[].path` is relative to `registry.json`. `files[].target` is relative to the root of the eve project that installs the item. Use `registry:item` with explicit `registry:file` targets for eve integrations so installation does not depend on a UI framework or shadcn project aliases.

Validate the source registry, then build its static JSON:

```bash
pnpm dlx shadcn@latest registry validate
pnpm dlx shadcn@latest build
```

By default, the build writes the catalog to `public/r/registry.json` and each item to `public/r/<name>.json`. Deploy the `public` directory to a static host, or use the shadcn registry APIs to serve the same payloads from dynamic routes.

Before sharing the registry, test its deployed catalog and item endpoints from an eve project:

```bash
eve registry list --registry https://registry.acme.com/r/registry.json
eve registry view https://registry.acme.com/r/analytics.json
```

Share the item URL template with consumers. From another eve project, they can add the hosted registry as a third-party source and pull the integration through its namespace:

```bash
eve registry add @acme=https://registry.acme.com/r/{name}.json
eve add @acme/analytics
```

## Configure generated files

Integrations add project files. Read the generated mount before you run the agent, then add the configuration the extension requires.

For an extension, this usually means setting environment variables and editing the file under `agent/extensions/`. See [Extensions](./extensions) for mount configuration, namespacing, and overrides.

Provider-specific setup lives in the [Integrations directory](/integrations). Follow that guidance for credentials, approval policies, and service-specific options.

## Update an installed integration

Treat generated files as project code. Commit or review local changes before you install the integration again.

Run the same command when the registry publisher provides an updated scaffold:

```bash
eve add extension/agent-browser
```

Pass `--overwrite` only when you intend to replace an existing generated file:

```bash
eve add extension/agent-browser --overwrite
```

Update the installed package with your package manager. Check the publisher's release notes before changing the generated mount or package version.

## Choose trusted sources

Integrations can add dependencies and write files. Add sources you trust, inspect an integration with `eve registry view`, and review the resulting project diff before you run the agent.

## What to read next

- [Extensions](./extensions): configure and override installed extension mounts
- [Integrations directory](/integrations): provider-specific setup and security guidance
- [shadcn registry documentation](https://ui.shadcn.com/docs/registry): publish a compatible third-party registry