How to integrate Launch darkly MCP with Vercel AI SDK v6

This guide walks you through connecting Launch darkly to Vercel AI SDK v6 using the Composio tool router. By the end, you'll have a working Launch darkly agent that can list all environments for your project, retrieve all custom roles for audit, create a trigger workflow for a flag through natural language commands. This guide will help you understand how to give your Vercel AI SDK agent real control over a Launch darkly account through Composio's Launch darkly MCP server. Before we dive in, let's take a quick look at the key ideas and tools involved.

Get started for freeGet a demo
Launch darkly logoLaunch darkly
Api Key

Launch darkly is a feature management platform for software teams to control feature flags. It helps you ship faster and safer by toggling features without redeploys.

248 Tools

Introduction

This guide walks you through connecting Launch darkly to Vercel AI SDK v6 using the Composio tool router. By the end, you'll have a working Launch darkly agent that can list all environments for your project, retrieve all custom roles for audit, create a trigger workflow for a flag through natural language commands.

This guide will help you understand how to give your Vercel AI SDK agent real control over a Launch darkly account through Composio's Launch darkly MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

Also integrate Launch darkly with

OpenAI Agents SDKClaude Agent SDKClaude CodeClaude CoworkCodexOpenClawHermesCLIGoogle ADKLangChainMastra AILlamaIndexCrewAI

TL;DR

Here's what you'll learn:
  • How to set up and configure a Vercel AI SDK agent with Launch darkly integration
  • Using Composio's Tool Router to dynamically load and access Launch darkly tools
  • Creating an MCP client connection using HTTP transport
  • Building an interactive CLI chat interface with conversation history management
  • Handling tool calls and results within the Vercel AI SDK framework

What is Vercel AI SDK?

The Vercel AI SDK is a TypeScript library for building AI-powered applications. It provides tools for creating agents that can use external services and maintain conversation state.

Key features include:

  • streamText: Core function for streaming responses with real-time tool support
  • MCP Client: Built-in support for Model Context Protocol via @ai-sdk/mcp
  • Step Counting: Control multi-step tool execution with stopWhen: stepCountIs()
  • OpenAI Provider: Native integration with OpenAI models

What is the Launch darkly MCP server, and what's possible with it?

The Launch darkly MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Launch darkly account. It provides structured and secure access to your feature management platform, so your agent can perform actions like managing feature flag workflows, listing projects, retrieving environments, and reviewing teams or custom roles.

  • Automated flag trigger workflows: Set up, modify, or delete flag trigger workflows so your agent can help automate feature releases and rollbacks in specific environments.
  • Comprehensive project and environment listing: Instantly retrieve all projects and their environments to help your agent audit, enumerate, or manage deployment contexts.
  • Team and role audits: List all teams and custom roles, making it easy for your agent to review permissions, conduct audits, or suggest configuration changes.
  • Code reference repository discovery: Pull complete lists of code reference repositories tied to your projects for better traceability and DevOps integration.
  • Effortless environment and project management: Quickly access and enumerate environments and projects to streamline workflows and improve operational oversight.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step09 STEPS
1

Prerequisites

Before you begin, make sure you have:
  • Node.js and npm installed
  • A Composio account with API key
  • An OpenAI API key
2

Getting API Keys for OpenAI and Composio

OpenAI API Key
  • Go to the OpenAI dashboard and create an API key. You'll need credits to use the models, or you can connect to another model provider.
  • Keep the API key safe.
Composio API Key
  • Log in to the Composio dashboard.
  • Navigate to your API settings and generate a new API key.
  • Store this key securely as you'll need it for authentication.
3

Install required dependencies

bash
npm install @ai-sdk/openai @ai-sdk/mcp @composio/core ai dotenv

First, install the necessary packages for your project.

What you're installing:

  • @ai-sdk/openai: Vercel AI SDK's OpenAI provider
  • @ai-sdk/mcp: MCP client for Vercel AI SDK
  • @composio/core: Composio SDK for tool integration
  • ai: Core Vercel AI SDK
  • dotenv: Environment variable management
4

Set up environment variables

bash
OPENAI_API_KEY=your_openai_api_key_here
COMPOSIO_API_KEY=your_composio_api_key_here
COMPOSIO_USER_ID=your_user_id_here

Create a .env file in your project root.

What's needed:

  • OPENAI_API_KEY: Your OpenAI API key for GPT model access
  • COMPOSIO_API_KEY: Your Composio API key for tool access
  • COMPOSIO_USER_ID: A unique identifier for the user session
5

Import required modules and validate environment

typescript
import "dotenv/config";
import { openai } from "@ai-sdk/openai";
import { Composio } from "@composio/core";
import * as readline from "readline";
import { streamText, type ModelMessage, stepCountIs } from "ai";
import { createMCPClient } from "@ai-sdk/mcp";

const composioAPIKey = process.env.COMPOSIO_API_KEY;
const composioUserID = process.env.COMPOSIO_USER_ID;

if (!process.env.OPENAI_API_KEY) throw new Error("OPENAI_API_KEY is not set");
if (!composioAPIKey) throw new Error("COMPOSIO_API_KEY is not set");
if (!composioUserID) throw new Error("COMPOSIO_USER_ID is not set");

const composio = new Composio({
  apiKey: composioAPIKey,
});
What's happening:
  • We're importing all necessary libraries including Vercel AI SDK's OpenAI provider and Composio
  • The dotenv/config import automatically loads environment variables
  • The MCP client import enables connection to Composio's tool server
6

Create Tool Router session and initialize MCP client

typescript
async function main() {
  // Create a tool router session for the user
  const session = await composio.create(composioUserID!, {
    toolkits: ["launch_darkly"],
  });

  const mcpUrl = session.mcp.url;
What's happening:
  • We're creating a Tool Router session that gives your agent access to Launch darkly tools
  • The create method takes the user ID and specifies which toolkits should be available
  • The returned mcp object contains the URL and authentication headers needed to connect to the MCP server
  • This session provides access to all Launch darkly-related tools through the MCP protocol
7

Connect to MCP server and retrieve tools

typescript
const mcpClient = await createMCPClient({
  transport: {
    type: "http",
    url: mcpUrl,
    headers: session.mcp.headers, // Authentication headers for the Composio MCP server
  },
});

const tools = await mcpClient.tools();
What's happening:
  • We're creating an MCP client that connects to our Composio Tool Router session via HTTP
  • The mcp.url provides the endpoint, and mcp.headers contains authentication credentials
  • The type: "http" is important - Composio requires HTTP transport
  • tools() retrieves all available Launch darkly tools that the agent can use
8

Initialize conversation and CLI interface

typescript
let messages: ModelMessage[] = [];

console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n");
console.log(
  "Ask any questions related to launch_darkly, like summarize my last 5 emails, send an email, etc... :)))\n",
);

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: "> ",
});

rl.prompt();
What's happening:
  • We initialize an empty messages array to maintain conversation history
  • A readline interface is created to accept user input from the command line
  • Instructions are displayed to guide the user on how to interact with the agent
9

Handle user input and stream responses with real-time tool feedback

typescript
rl.on("line", async (userInput: string) => {
  const trimmedInput = userInput.trim();

  if (["exit", "quit", "bye"].includes(trimmedInput.toLowerCase())) {
    console.log("\nGoodbye!");
    rl.close();
    process.exit(0);
  }

  if (!trimmedInput) {
    rl.prompt();
    return;
  }

  messages.push({ role: "user", content: trimmedInput });
  console.log("\nAgent is thinking...\n");

  try {
    const stream = streamText({
      model: openai("gpt-5"),
      messages,
      tools,
      toolChoice: "auto",
      stopWhen: stepCountIs(10),
      onStepFinish: (step) => {
        for (const toolCall of step.toolCalls) {
          console.log(`[Using tool: ${toolCall.toolName}]`);
          }
          if (step.toolCalls.length > 0) {
            console.log(""); // Add space after tool calls
          }
        },
      });

      for await (const chunk of stream.textStream) {
        process.stdout.write(chunk);
      }

      console.log("\n\n---\n");

      // Get final result for message history
      const response = await stream.response;
      if (response?.messages?.length) {
        messages.push(...response.messages);
      }
    } catch (error) {
      console.error("\nAn error occurred while talking to the agent:");
      console.error(error);
      console.log(
        "\nYou can try again or restart the app if it keeps happening.\n",
      );
    } finally {
      rl.prompt();
    }
  });

  rl.on("close", async () => {
    await mcpClient.close();
    console.log("\n👋 Session ended.");
    process.exit(0);
  });
}

main().catch((err) => {
  console.error("Fatal error:", err);
  process.exit(1);
});
What's happening:
  • We use streamText instead of generateText to stream responses in real-time
  • toolChoice: "auto" allows the model to decide when to use Launch darkly tools
  • stopWhen: stepCountIs(10) allows up to 10 steps for complex multi-tool operations
  • onStepFinish callback displays which tools are being used in real-time
  • We iterate through the text stream to create a typewriter effect as the agent responds
  • The complete response is added to conversation history to maintain context
  • Errors are caught and displayed with helpful retry suggestions

Complete Code

Here's the complete code to get you started with Launch darkly and Vercel AI SDK:

typescript
import "dotenv/config";
import { openai } from "@ai-sdk/openai";
import { Composio } from "@composio/core";
import * as readline from "readline";
import { streamText, type ModelMessage, stepCountIs } from "ai";
import { createMCPClient } from "@ai-sdk/mcp";

const composioAPIKey = process.env.COMPOSIO_API_KEY;
const composioUserID = process.env.COMPOSIO_USER_ID;

if (!process.env.OPENAI_API_KEY) throw new Error("OPENAI_API_KEY is not set");
if (!composioAPIKey) throw new Error("COMPOSIO_API_KEY is not set");
if (!composioUserID) throw new Error("COMPOSIO_USER_ID is not set");

const composio = new Composio({
  apiKey: composioAPIKey,
});

async function main() {
  // Create a tool router session for the user
  const session = await composio.create(composioUserID!, {
    toolkits: ["launch_darkly"],
  });

  const mcpUrl = session.mcp.url;

  const mcpClient = await createMCPClient({
    transport: {
      type: "http",
      url: mcpUrl,
      headers: session.mcp.headers, // Authentication headers for the Composio MCP server
    },
  });

  const tools = await mcpClient.tools();

  let messages: ModelMessage[] = [];

  console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n");
  console.log(
    "Ask any questions related to launch_darkly, like summarize my last 5 emails, send an email, etc... :)))\n",
  );

  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: "> ",
  });

  rl.prompt();

  rl.on("line", async (userInput: string) => {
    const trimmedInput = userInput.trim();

    if (["exit", "quit", "bye"].includes(trimmedInput.toLowerCase())) {
      console.log("\nGoodbye!");
      rl.close();
      process.exit(0);
    }

    if (!trimmedInput) {
      rl.prompt();
      return;
    }

    messages.push({ role: "user", content: trimmedInput });
    console.log("\nAgent is thinking...\n");

    try {
      const stream = streamText({
        model: openai("gpt-5"),
        messages,
        tools,
        toolChoice: "auto",
        stopWhen: stepCountIs(10),
        onStepFinish: (step) => {
          for (const toolCall of step.toolCalls) {
            console.log(`[Using tool: ${toolCall.toolName}]`);
          }
          if (step.toolCalls.length > 0) {
            console.log(""); // Add space after tool calls
          }
        },
      });

      for await (const chunk of stream.textStream) {
        process.stdout.write(chunk);
      }

      console.log("\n\n---\n");

      // Get final result for message history
      const response = await stream.response;
      if (response?.messages?.length) {
        messages.push(...response.messages);
      }
    } catch (error) {
      console.error("\nAn error occurred while talking to the agent:");
      console.error(error);
      console.log(
        "\nYou can try again or restart the app if it keeps happening.\n",
      );
    } finally {
      rl.prompt();
    }
  });

  rl.on("close", async () => {
    await mcpClient.close();
    console.log("\n👋 Session ended.");
    process.exit(0);
  });
}

main().catch((err) => {
  console.error("Fatal error:", err);
  process.exit(1);
});

Conclusion

You've successfully built a Launch darkly agent using the Vercel AI SDK with streaming capabilities! This implementation provides a powerful foundation for building AI applications with natural language interfaces and real-time feedback.

Key features of this implementation:

  • Real-time streaming responses for a better user experience with typewriter effect
  • Live tool execution feedback showing which tools are being used as the agent works
  • Dynamic tool loading through Composio's Tool Router with secure authentication
  • Multi-step tool execution with configurable step limits (up to 10 steps)
  • Comprehensive error handling for robust agent execution
  • Conversation history maintenance for context-aware responses

You can extend this further by adding custom error handling, implementing specific business logic, or integrating additional Composio toolkits to create multi-app workflows.
TOOLS

Supported Tools

Every Launch darkly action and event your agent gets out of the box.

Add Member to Teams

Tool to add a LaunchDarkly member to one or more teams.

Apply Approval Request

Tool to apply an approved approval request in LaunchDarkly.

Apply Approval Request for Flag

Tool to apply an approved approval request for a feature flag in LaunchDarkly.

Copy Feature Flag

Tool to copy a feature flag's configuration from one environment to another within the same project.

Create Announcement

Tool to create a public announcement in LaunchDarkly.

Create Approval Request

Tool to create an approval request in LaunchDarkly.

Create Approval Request for Flag

Tool to create an approval request for a feature flag in LaunchDarkly.

Create Approval Request Review

Tool to review an approval request by approving, declining, or commenting on changes.

Create Approval Request Review for Flag

Tool to review an approval request for a feature flag by approving, declining, or commenting on the changes.

Create Big Segment Export

Tool to create an export for a big segment in LaunchDarkly.

Create Big Segment Store Integration

Tool to create a persistent store integration for big segments in LaunchDarkly.

Create Custom Role

Tool to create a new custom role in LaunchDarkly.

Create Data Export Destination

Tool to create a new Data Export destination for exporting LaunchDarkly event data to external services.

Create Environment

Tool to create a new environment within a LaunchDarkly project.

Create Experiment

Tool to create a new experiment in LaunchDarkly.

Create Extinction Events

Tool to create new extinction events for feature flags in LaunchDarkly.

Create Feature Flag

Tool to create a new feature flag in LaunchDarkly.

Create Flag Scheduled Changes

Tool to create a scheduled changes workflow for a feature flag in LaunchDarkly.

Create Flag Copy Config Approval Request

Tool to create an approval request for copying a feature flag's configuration from one environment to another.

Create Flag Import Configuration

Tool to create a new flag import configuration for importing feature flags from external feature management systems like Split or Unleash.

Create Flag Link

Tool to create a new flag link in LaunchDarkly.

Create Holdout

Tool to create a new holdout in LaunchDarkly for experiment control groups.

Create Integration Configuration

Tool to create a new integration configuration in LaunchDarkly.

Create Experiment Iteration

Tool to create a new iteration for an experiment in LaunchDarkly.

Create Layer

Tool to create a new layer in a LaunchDarkly project.

Create Members

Tool to invite one or more new members to join a LaunchDarkly account.

Create Metric

Tool to create a new metric in LaunchDarkly.

Create Metric Group

Tool to create a new metric group in LaunchDarkly.

Create Migration Safety Issues

Tool to check migration safety issues for a feature flag patch.

Create OAuth 2.0 Client

Tool to create (register) a LaunchDarkly OAuth 2.

Create Project

Tool to create a new project with the given key and name.

Create Relay Proxy Auto Configuration

Tool to create a new Relay Proxy configuration in LaunchDarkly.

Create Release for Flag

Tool to create a release by adding a flag to a release pipeline in LaunchDarkly.

Create Release Pipeline

Tool to create a release pipeline in LaunchDarkly.

Create Release Policy

Tool to create a new release policy for a specified project.

Create Repository

Tool to create a code reference repository with the specified name.

Create Segment

Tool to create a new segment in LaunchDarkly.

Create Audit Log Subscription

Tool to create a new audit log subscription for forwarding LaunchDarkly audit events to external services.

Create Team

Tool to create a new team in LaunchDarkly.

Create Flag Trigger Workflow

Creates a flag trigger workflow in LaunchDarkly.

Create Webhook

Tool to create a new webhook in LaunchDarkly.

Create Workflow

Tool to create a workflow in LaunchDarkly for automating flag changes.

Create Workflow Template

Tool to create a workflow template in LaunchDarkly.

Delete Announcement

Tool to permanently delete an announcement from LaunchDarkly.

Delete Approval Request

Tool to delete an approval request in LaunchDarkly.

Delete Approval Request for Flag

Permanently deletes an approval request for a feature flag in LaunchDarkly.

Delete Big Segment Store Integration

Tool to permanently delete a persistent store integration for big segments.

Delete Branches from Code Reference Repository

Asynchronously deletes multiple branches from a LaunchDarkly code reference repository.

Delete Custom Role

Permanently deletes a custom role from LaunchDarkly.

Delete Data Export Destination

Permanently deletes a Data Export destination from LaunchDarkly.

Delete Environment

Tool to permanently delete an environment from a LaunchDarkly project.

Delete Feature Flag

Tool to permanently delete a feature flag from LaunchDarkly.

Delete Flag Scheduled Changes

Tool to delete scheduled changes workflow for a feature flag in LaunchDarkly.

Delete Flag Import Configuration

Tool to delete a flag import configuration by ID.

Delete Flag Link

Permanently deletes a flag link from LaunchDarkly.

Delete Integration Configuration

Permanently deletes an integration configuration from LaunchDarkly.

Delete Account Member

Tool to permanently delete an account member from LaunchDarkly.

Delete Metric

Tool to permanently delete a metric from LaunchDarkly.

Delete Metric Group

Tool to permanently delete a metric group from LaunchDarkly.

Delete OAuth 2.0 Client

Permanently deletes an OAuth 2.

Delete Project

Tool to permanently delete a project from LaunchDarkly.

Delete Relay Proxy Auto Configuration

Tool to delete a Relay Proxy auto configuration by ID.

Delete Release by Flag Key

Tool to delete a release from a feature flag.

Delete Release Pipeline

Tool to permanently delete a release pipeline from LaunchDarkly.

Delete Release Policy

Tool to permanently delete a release policy from a LaunchDarkly project.

Delete Repository

Tool to delete a code reference repository with the specified name.

Delete Segment

Permanently deletes a segment from LaunchDarkly.

Delete Audit Log Subscription

Tool to permanently delete an audit log subscription in LaunchDarkly.

Delete Team

Permanently deletes a team from LaunchDarkly organization.

Delete Access Token

Tool to permanently delete an access token from LaunchDarkly.

Delete Flag Trigger Workflow

Permanently deletes a flag trigger workflow from LaunchDarkly.

Delete Webhook

Tool to delete a webhook from LaunchDarkly.

Delete Workflow

Permanently deletes a workflow from LaunchDarkly.

Delete Workflow Template

Permanently deletes a workflow template from LaunchDarkly.

Evaluate Context Instance

Tool to evaluate flags for a context instance to determine expected flag variations.

Generate Trust Policy for Data Export

Tool to generate an AWS trust policy for Data Export destinations.

Get All Holdouts

Tool to retrieve all holdouts for a specific project and environment.

Get All Integration Configurations

Tool to retrieve all integration configurations for a specific integration key.

Get All Release Pipelines

Tool to retrieve all release pipelines for a project.

Get All Webhooks

Tool to retrieve all webhooks configured in the LaunchDarkly account.

Get Announcements Public

Tool to retrieve public announcements from LaunchDarkly.

Get Applications

Tool to retrieve a list of applications in LaunchDarkly.

Get Application Versions

Tool to retrieve all versions for a specific application in LaunchDarkly.

Get Approval for Flag

Tool to get a single approval request for a feature flag in LaunchDarkly.

Get Approval Request

Tool to get a specific approval request by ID from LaunchDarkly.

Get Approval Requests

Tool to retrieve all approval requests from LaunchDarkly.

Get Approval Request Settings

Tool to retrieve approval request settings for a project.

Get Approvals for Flag

Tool to retrieve all approval requests for a specific feature flag in an environment.

Get Audit Log Entries

Tool to get a list of all audit log entries.

Get Audit Log Entry

Tool to retrieve a single audit log entry by ID.

Get Big Segment Export

Tool to retrieve a specific big segment export by its ID.

Get Big Segment Import

Tool to retrieve the status and details of a big segment import by its ID.

Get Big Segment Store Integration

Tool to retrieve a specific persistent store integration for big segments by its ID.

Get Big Segment Store Integrations

Tool to retrieve all persistent store integrations for big segments.

Get Branch

Tool to retrieve branch information from a LaunchDarkly code reference repository.

Get Caller Identity

Tool to retrieve basic information about the identity used to authenticate API calls.

Get Context Attribute Names

Tool to retrieve context attribute names for a project and environment.

Get Context Attribute Values

Tool to retrieve unique values for a specific context attribute within a project environment.

Get Context Instances

Tool to get context instances for a specific context ID within a project and environment.

Get Context Kinds By Project Key

Tool to retrieve all context kinds for a given project.

Get Contexts

Tool to retrieve context instances from a LaunchDarkly environment by kind and key.

Get Contexts Clientside Usage

Tool to get a detailed time series of context key usages observed by LaunchDarkly in your account, including non-primary context kinds.

Get Contexts Serverside Usage

Tool to get detailed time series of context key usages observed by LaunchDarkly in your account, including non-primary context kinds.

Get Contexts Total Usage

Tool to get a detailed time series of the number of context key usages observed by LaunchDarkly in your account, including non-primary context kinds.

Get Context Instance Segments Membership By Environment

Tool to get segment membership details for a given context instance with attributes.

Get Custom Role

Tool to retrieve a single custom role by key or ID.

Get Custom Roles

Tool to retrieve a list of all custom roles.

Get Custom Workflow

Tool to retrieve details of a specific custom workflow by ID.

Get Data Export Events Usage

Tool to retrieve a time series array showing the number of data export events from your account.

Get Dependent Flags

Tool to list dependent feature flags for a specific flag.

Get Dependent Flags By Environment

Tool to list dependent flags across all environments for a specified flag.

Get Data Export Destination

Tool to retrieve a specific Data Export destination by ID.

Get Data Export Destinations

Tool to retrieve all Data Export destinations configured across all projects and environments.

Get Environment

Tool to retrieve a specific environment by project key and environment key.

Get Environments

Tool to retrieve a list of all environments within a project.

Get Evaluations Usage

Tool to get time-series arrays of flag evaluation counts, broken down by variation.

Get Events Usage

Tool to get time-series arrays of flag evaluation events.

Get Experiment

Tool to retrieve a specific experiment by project key, environment key, and experiment key.

Get Experimentation Events Usage

Tool to retrieve a time series array showing the number of experimentation events from your account.

Get Experimentation Keys Usage

Tool to get a time series showing the number of experimentation keys from your account.

Get Experimentation Settings

Tool to retrieve experimentation settings for a project.

Get Experiments

Tool to retrieve experiments from a project and environment.

Get Expiring Context Targets

Tool to retrieve context targets scheduled for removal from a feature flag.

Get Expiring Targets For Segment

Tool to retrieve context targets scheduled for removal from a segment.

Get Extinctions

Tool to get a list of all extinctions.

Get Feature Flag

Tool to retrieve a specific feature flag by project key and flag key.

Get Feature Flags

Tool to retrieve a list of all feature flags in a project.

Get Feature Flag Scheduled Change

Tool to retrieve a specific scheduled change for a feature flag.

Get Feature Flag Status

Tool to retrieve the status of a feature flag.

Get Feature Flag Status Across Environments

Tool to retrieve the status of a feature flag across all environments in a project.

Get Feature Flag Statuses

Tool to retrieve status information for all feature flags in a project environment.

Get Flag Scheduled Changes

Tool to retrieve scheduled changes for a feature flag.

Get Flag Defaults by Project

Tool to retrieve flag defaults for a specific project.

Get Flag Followers

Tool to retrieve followers of a flag in a project and environment.

Get Flag Import Configuration

Tool to retrieve a single flag import configuration by project key, integration key, and integration ID.

Get Flag Import Configurations

Tool to list all flag import configurations.

Get Flag Links

Tool to retrieve all flag links for a specific feature flag.

Get Followers By Project and Environment

Tool to retrieve followers of all flags in a given project and environment.

Get Holdout

Tool to retrieve a specific holdout experiment by project key, environment key, and holdout key.

Get Integration Configuration

Tool to retrieve a specific integration configuration by ID.

Get Integration Delivery Configuration by Environment

Tool to get delivery configurations by environment for feature store integrations.

Get IPs

Tool to retrieve the list of IP ranges used by the LaunchDarkly service.

Get Layers

Tool to retrieve layers for a project.

Get MAU Clientside Usage

Tool to get a time series of context key usages observed by LaunchDarkly client-side SDKs for the primary context kind.

Get MAU Total Usage

Tool to get a time series of the number of context key usages observed by LaunchDarkly in your account, for the primary context kind only.

Get MAU Usage

Tool to get a time-series array of monthly active users (MAU) seen by LaunchDarkly from your account.

Get MAU Usage By Category

Tool to get time-series arrays of monthly active users (MAU) by category (browser, mobile, or backend).

Get Account Member

Tool to retrieve detailed information about a specific LaunchDarkly account member.

Get Members

Tool to retrieve a list of account members.

Get Metric

Tool to retrieve a specific metric by project key and metric key.

Get Metric Group

Tool to retrieve a specific metric group by project key and metric group key.

Get OAuth 2.0 Client by ID

Tool to retrieve a registered OAuth 2.

Get OAuth 2.0 Clients

Tool to retrieve all OAuth 2.

Get Observability Errors Usage

Tool to get time-series arrays of the number of observability errors.

Get Observability Logs Usage

Tool to retrieve time-series arrays of observability logs usage data.

Get Observability Sessions Usage

Tool to get time-series arrays of the number of observability sessions.

Get Observability Traces Usage

Tool to retrieve time-series arrays of observability traces usage data.

Get OpenAPI Spec

Tool to retrieve the latest OpenAPI specification for LaunchDarkly's API in JSON format.

Get Project

Tool to retrieve a specific project by project key.

Get Relay Proxy Config

Tool to retrieve a single Relay Proxy auto configuration by ID.

Get Relay Proxy Configs

Tool to retrieve all Relay Proxy configurations in the LaunchDarkly account.

Get Release by Flag Key

Tool to retrieve the currently active release for a feature flag.

Get Release Pipeline by Key

Tool to retrieve a release pipeline by its key.

Get Release Policies

Tool to retrieve a list of release policies for a specified project.

Get Release Policy

Tool to retrieve a single release policy by its key for a specified project.

Get All Release Progressions for Release Pipeline

Tool to retrieve details on the progression of all releases, across all flags, for a release pipeline.

Get Repository

Tool to get a single code reference repository by name.

Get Root

Tool to retrieve the LaunchDarkly API root resource.

Get Root Code Reference Statistic

Tool to get links to code reference repositories for each project.

Get Segment

Tool to retrieve a specific segment by segment key.

Get Segment Membership For Context

Tool to get big segment membership status for a specific context.

Get Segments

Tool to retrieve a list of all segments in a project and environment.

Get Service Connections Usage

Tool to get a time series array showing the number of service connection minutes from your account.

Get Code References Statistics

Tool to retrieve code references statistics for feature flags.

Get Stream Usage

Tool to get time-series data of streaming connections to LaunchDarkly.

Get Stream Usage By SDK Version

Tool to get time-series data of streaming connections to LaunchDarkly, separated by SDK type and version.

Get Stream Usage SDK Versions

Tool to get a list of SDK version objects from LaunchDarkly.

Get Audit Log Subscription by ID

Tool to retrieve a specific audit log subscription by ID.

Get Audit Log Subscriptions by Integration

Tool to retrieve all audit log subscriptions for a given integration.

Get Tags

Tool to retrieve a list of tags from LaunchDarkly.

Get Team

Tool to fetch a specific team by key.

Get Team Maintainers

Tool to retrieve the list of maintainers for a specific LaunchDarkly team.

Get Team Roles

Tool to fetch the custom roles that have been assigned to a team.

Get Access Token

Tool to retrieve detailed information about a specific LaunchDarkly access token by its ID.

Get Tokens

Tool to fetch a list of all access tokens.

Get Flag Trigger by ID

Tool to retrieve details of a specific flag trigger by ID.

Get Flag Trigger Workflows

Tool to retrieve all flag triggers for a specific feature flag in an environment.

Get Versions

Tool to retrieve LaunchDarkly API version information.

Get Webhook

Tool to retrieve a specific webhook by ID.

Get Workflows

Tool to retrieve workflows for a specific feature flag in an environment.

Get Workflow Templates

Tool to retrieve workflow templates belonging to an account.

List Branches in Code Reference Repository

Tool to list branches in a LaunchDarkly code reference repository.

List Code Reference Repositories

Lists all code reference repositories configured in LaunchDarkly.

List Integration Delivery Configurations

Tool to list all integration delivery configurations.

List Metric Groups

Tool to retrieve a list of all metric groups in a project.

List Metrics

Tool to retrieve a list of all metrics in a project.

List Projects

Tool to retrieve a list of all projects.

List Teams

Fetches one page of teams from LaunchDarkly.

Patch Approval Request Settings

Tool to perform a partial update to approval request settings for a project.

Patch Big Segment Store Integration

Tool to update a persistent store integration for big segments using JSON Patch operations.

Patch Custom Role

Tool to update a custom role's settings using JSON Patch operations.

Update Data Export Destination

Tool to update a Data Export destination using JSON Patch operations.

Patch Environment

Tool to update an environment's settings using JSON Patch operations.

Patch Experiment

Tool to update an experiment using semantic patch format.

Patch Expiring Targets

Tool to update expiring context targets on a feature flag.

Patch Feature Flag

Tool to update a feature flag's settings using JSON Patch operations.

Patch Flag Config Approval Request

Tool to perform a partial update to a flag config approval request using semantic patch format.

Patch Flag Scheduled Change

Tool to update a scheduled change workflow for a feature flag.

Patch Flag Defaults By Project

Tool to update flag defaults for a project using JSON Patch operations.

Patch Flag Import Configuration

Tool to update a flag import configuration using JSON Patch operations.

Patch Holdout

Tool to update a LaunchDarkly holdout using semantic patch operations.

Patch Account Member

Tool to modify an account member's information using JSON Patch operations.

Patch Members

Tool to perform partial updates to multiple LaunchDarkly account members using semantic patch format.

Patch Metric

Tool to update a metric's settings using JSON Patch operations.

Patch Metric Group

Tool to update a metric group's settings using JSON Patch operations.

Patch OAuth 2.0 Client

Tool to update an existing OAuth 2.

Update Project

Tool to update a LaunchDarkly project using JSON Patch operations (RFC 6902).

Update Relay Proxy Config

Tool to update a Relay Proxy auto configuration using JSON Patch operations (RFC 6902).

Patch Repository

Tool to update a code reference repository's settings using JSON Patch operations.

Patch Segment

Tool to update a segment's settings using JSON Patch operations.

Patch Team

Tool to perform partial updates to a LaunchDarkly team using semantic patch format.

Patch Teams

Tool to perform partial updates to multiple LaunchDarkly teams using semantic patch format.

Patch Access Token

Tool to update an access token's settings using JSON Patch operations.

Update Flag Trigger

Tool to update a flag trigger using semantic patch operations.

Update Webhook

Tool to update a LaunchDarkly webhook using JSON Patch operations (RFC 6902).

Create or Update Flag Defaults by Project

Tool to create or update flag defaults for a specific project.

Reset Environment Mobile Key

Tool to reset the mobile SDK key for a specific environment.

Reset Environment SDK Key

Tool to reset the SDK key for a specific environment.

Reset Relay Proxy Configuration Key

Tool to reset the Relay Proxy configuration key.

Reset Access Token

Tool to reset a LaunchDarkly access token, generating a new token value.

Search Audit Log Entries

Search audit log entries in LaunchDarkly.

Search Context Instances

Tool to search for context instances within a project and environment.

Search Contexts

Tool to search for contexts in a LaunchDarkly environment with flexible filtering and sorting.

Trigger Flag Import Job

Tool to trigger a single flag import run for an existing flag import configuration.

Update Announcement

Tool to update an existing announcement in LaunchDarkly using JSON Patch operations.

Update Big Segment Context Targets

Tool to update context targets included or excluded in a big segment.

Update Context Flag Setting

Tool to enable or disable a feature flag for a specific context based on its context kind and key.

Create or Update Context Kind

Tool to create or update a context kind in a LaunchDarkly project.

Update Experimentation Settings

Tool to update experimentation settings for a project.

Update Flag Link

Tool to update an existing flag link in LaunchDarkly using JSON Patch operations.

Update Integration Configuration

Tool to update an existing integration configuration in LaunchDarkly using JSON Patch operations.

Update Layer

Tool to update a layer using semantic patch instructions.

Update Phase Status

Tool to update the execution status of a phase in a feature flag release.

Update Release Pipeline

Tool to update an existing release pipeline in LaunchDarkly.

Update Release Policies Order

Tool to update the order of existing release policies for a project.

Update Release Policy

Tool to update an existing release policy for a specified project.

Update Audit Log Subscription

Tool to update an audit log subscription configuration using JSON Patch operations.

Upsert Branch in Code Reference Repository

Tool to upsert (create or update) a branch in a LaunchDarkly code reference repository.

FRAMEWORKS

How to build Launch darkly MCP Agent with another framework

OpenAI Agents SDK logo

OpenAI Agents SDK

Use Launch darkly MCP with OpenAI Agents SDK

Claude Agent SDK logo

Claude Agent SDK

Use Launch darkly MCP with Claude Agent SDK

Claude Code logo

Claude Code

Use Launch darkly MCP with Claude Code

Claude Cowork logo

Claude Cowork

Use Launch darkly MCP with Claude Cowork

Codex logo

Codex

Use Launch darkly MCP with Codex

OpenClaw logo

OpenClaw

Use Launch darkly MCP with OpenClaw

Hermes logo

Hermes

Use Launch darkly MCP with Hermes

CLI logo

CLI

Use Launch darkly MCP with CLI

Google ADK logo

Google ADK

Use Launch darkly MCP with Google ADK

LangChain logo

LangChain

Use Launch darkly MCP with LangChain

Mastra AI logo

Mastra AI

Use Launch darkly MCP with Mastra AI

LlamaIndex logo

LlamaIndex

Use Launch darkly MCP with LlamaIndex

CrewAI logo

CrewAI

Use Launch darkly MCP with CrewAI

FAQ

Frequently asked questions

With a standalone Launch darkly MCP server, the agents and LLMs can only access a fixed set of Launch darkly tools tied to that server. However, with the Composio Tool Router, agents can dynamically load tools from Launch darkly and many other apps based on the task at hand, all through a single MCP endpoint.

Yes, you can. Vercel AI SDK v6 fully supports MCP integration. You get structured tool calling, message history handling, and model orchestration while Tool Router takes care of discovering and serving the right Launch darkly tools.

Yes, absolutely. You can configure which Launch darkly scopes and actions are allowed when connecting your account to Composio. You can also bring your own OAuth credentials or API configuration so you keep full control over what the agent can do.

All sensitive data such as tokens, keys, and configuration is fully encrypted at rest and in transit. Composio is SOC 2 Type 2 compliant and follows strict security practices so your Launch darkly data and credentials are handled as safely as possible.

Start with Launch darkly.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Launch darkly tool your agent needs.Free to start.

Start building
Customer stories

Teams ship real agents on Composio

GET STARTED FOR FREEBOOK A DEMO
agent.aiZoomLettaGleanHubSpotAWSWabi

Karan skipped his own birthday party to fix our critical issue. It was 10pm and he diverted his Waymo to help us instead. This really sets the bar — it shows the commitment you need when users rely on your software.

Harsha Gaddipati
Harsha Gaddipati
Co-founder, Slashy

A lot of students tell us that the moment their connected tools start talking to each other inside Opennote feels almost magical. The agent just knows them, and it's immensely helped keep new users on the platform.

Abhi Arya
Abhi Arya
Co-founder, Opennote

We chose Composio over Pipedream because it delivered depth where it mattered — niche tools and tricky edge cases other platforms simply ignored. That gave us confidence to scale without compromising.

Nirman Dave
Nirman Dave
CEO, Zams

As a solo builder, shipping fast is life or death. The only way I can outcompete incumbents is by outmanoeuvring them. Getting bogged down managing agent auth would have been a death sentence.

Ryan Yu
Ryan Yu
Founder, Extra Thursday

Before Composio, adding tool integrations was slow and resource-intensive. Each one could take weeks of engineering time, and maintaining them meant constantly keeping up with API changes.

Tomisin Jenrola
Tomisin Jenrola
Founder & CEO, SwarmZero

With hands-on help from their founder, we integrated Gmail and Google Drive in just 30 minutes. This level of personal support and commitment is exactly what startups should strive for.

Jerome Leclanche
Jerome Leclanche
Co-Founder, Ingram Technologies