Connections & Tools

Give the agent access to external systems while keeping credentials and implementation details out of model context.

Choose the right capability

Connections live in agent/connections/. Eve discovers remote operations, keeps tokens away from the model, and exposes matching operations through the built-in connection_search tool.

Create a Supabase project

Create and seed the database before adding the MCP connection so your first authorized request has a real project and schema to discover.

1. 1

   Provision the database through the Vercel Marketplace.

   Open Supabase in the Vercel Marketplace, select Install, and create a Supabase project using the default Free plan.

   After the database is provisioned, Vercel prompts you to connect it to a project. Select the Vercel project that contains your eve agent.

2. 2

   Create the workshop tables.

   Go to your eve project at vercel.com/<team-name>/<eve-project-name>, replacing the placeholders with your Vercel team and project names. In the project sidebar, select Storage, then open the Supabase database you just provisioned.

   Select Open in Supabase. In the Supabase dashboard, select SQL Editor from the left sidebar, then run:

   create table if not exists public.accounts (
     account_id text primary key,
     plan text not null,
     status text not null check (status in ('active', 'past_due', 'suspended')),
     region text not null,
     open_incidents integer not null default 0 check (open_incidents >= 0)
   );
    
   create table if not exists public.tickets (
     ticket_id text primary key,
     account_id text not null references public.accounts(account_id),
     status text not null check (status in ('open', 'investigating', 'resolved')),
     internal_note text not null default '',
     updated_at timestamptz not null default now()
   );
    
   alter table public.accounts enable row level security;
   alter table public.tickets enable row level security;
    
   insert into public.accounts
     (account_id, plan, status, region, open_incidents)
   values
     ('acct_123', 'Pro', 'active', 'iad1', 1)
   on conflict (account_id) do update set
     plan = excluded.plan,
     status = excluded.status,
     region = excluded.region,
     open_incidents = excluded.open_incidents;
    
   insert into public.tickets
     (ticket_id, account_id, status, internal_note)
   values
     ('TKT-1042', 'acct_123', 'open', 'Sign-in failure reported after deployment.')
   on conflict (ticket_id) do nothing;

   Copy

   This creates and seeds the deterministic workshop data before eve connects to Supabase. Row Level Security is enabled without public policies, so the publishable key cannot read these support tables. In the next section, you will gate a Supabase MCP mutation behind human approval.

The Marketplace integration and the MCP connector serve different purposes: the Marketplace provisions the database, while Vercel Connect authorizes eve to use Supabase on behalf of the signed-in user.

Add eve's Supabase MCP connection

Install the official connection from eve's registry:

The command installs the authentication dependency and writes agent/connections/supabase.ts. Review generated files before running them. The connection should look like:

import { connect } from "@vercel/connect/eve";
import { defineMcpClientConnection } from "eve/connections";
 
export default defineMcpClientConnection({
  url: "https://mcp.supabase.com/mcp",
  description: "Supabase: databases, authentication, and storage.",
  auth: connect("mcp.supabase.com/<your-connector-name>"),
});

The eve add command writes the full connector UID here automatically. The final segment is the connector name, so a connector named support-agent-test appears as auth: connect("mcp.supabase.com/support-agent-test").

The filename registers the connection as supabase, while the value passed to connect() identifies the Vercel Connect integration used for authorization. Eve discovers its remote tools through connection_search and exposes matches as supabase__<tool>.

The recommended setup path has already linked the Vercel project and pulled a local OIDC token. The eve add command reuses that link, creates or attaches the Supabase connector, and updates the generated connection with its UID.

1. 1

   Exercise authorization.

   npm run dev

   PromptCopy

   Use the Supabase connection to find the project I just created. List the tables in its public schema and briefly describe the accounts and tickets tables. Do not modify anything.

   Watch for connection_search followed by qualified supabase__<tool> calls that inspect the project and list its tables. The first call for a user opens Supabase authorization in their browser; eve parks the turn and resumes it after consent.

What this exercise teaches

The lookup_account tool from the guided build and the Supabase connection are two different ways to give an agent capabilities:

• An authored tool gives the model a narrow contract backed by code you own.
• An MCP connection adopts operations published by an external service and authorizes them for the current user.

In this exercise, Supabase defines the available operations and eve discovers them at runtime. You do not need to recreate those operations as authored tools. In the next section, you will add an approval policy directly to the connection so a person must authorize a mutation before it runs.

You are ready when

• A Free-plan Supabase project is connected to your Vercel project.
• The accounts and tickets tables exist in its public schema.
• The connection file contains the full UID for your Vercel Connect connector.
• The first connection call requests Supabase authorization.
• The authorized call resumes the same turn and uses a qualified supabase__<tool> operation to inspect the tables.
• The connection describes the accounts and tickets tables without modifying them.