LaunchDarkly Projects Setup

Prerequisites

• LaunchDarkly API access token with

  projects:write

  permission
• LaunchDarkly MCP server configured in your environment

Core Principles

1. Understand First: Explore the codebase to understand the stack and patterns.
2. Choose the Right Fit: Select an approach that matches your architecture.
3. Follow Conventions: Respect existing code style and structure.
4. Verify Integration: Confirm the setup works: the agent performs checks and reports results.

API Key Detection

1. Check environment variables: Look for

   LAUNCHDARKLY_API_KEY

   ,

   LAUNCHDARKLY_API_TOKEN

   , or

   LD_API_KEY

2. Check MCP config: If using Claude, read

   ~/.claude/config.json

   for

   mcpServers.launchdarkly.env.LAUNCHDARKLY_API_KEY

3. Prompt user: Only if detection fails, ask the user for their API key

What Are Projects?

• All your configs
• Feature flags and segments
• Multiple environments (Production and Test created by default)

Project Setup Workflow

Step 1: Explore the Codebase

1. Identify the tech stack:
   • What language(s)? (Python, Node.js, Go, Java, etc.)
   • What framework(s)? (FastAPI, Express, Spring Boot, etc.)
   • Is there an existing LaunchDarkly integration?
2. Check environment management:
   • How are environment variables stored? (.env files, secrets manager, config files)
   • Where is configuration loaded? (startup scripts, config modules)
   • Are there existing LaunchDarkly SDK keys?
3. Look for patterns:
   • Are there existing API clients or service modules?
   • How is external API integration typically done?
   • Is there a CLI, scripts directory, or admin tooling?
4. Understand the use case:
   • Is this a new project being set up?
   • Adding to an existing LaunchDarkly integration?
   • Part of a multi-service architecture?
   • Need for project cloning across regions/teams?

Step 2: Assess the Situation

Step 3: Choose Your Implementation Path

• Python Implementation - For Python applications (FastAPI, Django, Flask)
• Node.js/TypeScript Implementation - For Node.js/Express/NestJS applications
• Go Implementation - For Go services
• Multi-Language Setup - For polyglot architectures

• Quick Start - Create first project and get SDK keys
• Environment Configuration - Save SDK keys to .env, secrets, or config
• Project Cloning - Clone projects for regions/teams
• IaC/Automation - Terraform, scripts, CI/CD integration
• Admin Tooling - Build CLI or admin utilities

Step 4: Implement the Integration

1. API Authentication:
   • Store API token securely
   • Follow existing secrets management patterns
   • Never commit tokens to version control
2. Project Naming:
   • Use consistent, descriptive names
   • Follow existing naming conventions
   • Project keys: lowercase, hyphens, start with letter
3. SDK Key Management:
   • Extract and store SDK keys for each environment
   • Use the same pattern as other secrets in your codebase
   • Consider separate keys for test/staging/production
4. Error Handling:
   • Handle existing projects gracefully (409 conflict)
   • Provide clear error messages
   • Don't fail silently

Step 5: Verify the Setup

1. Fetch to confirm it exists. Prefer the MCP

   get-project

   tool over raw

   curl

   — it returns a typed object you can inspect directly. If you must call the REST API:
   bash

   curl -X GET "https://app.launchdarkly.com/api/v2/projects/{projectKey}?expand=environments" \
     -H "Authorization: {api_token}"

   Do not pipe the response straight into a

   .environments.items[]

   -style

   jq

   filter. The shape of

   environments

   varies by

   expand

   parameter — sometimes it's

   {items: [...]}

   , sometimes a bare array — and a hand-rolled filter will fail with

   Cannot index array with string "items"

   . Run

   jq -e .

   first to inspect the actual shape, or use

   jq '.environments | if type == "object" then .items else . end'

   to handle both.
2. Test SDK integration: Run a quick verification to ensure the SDK key works:
   python

   import ldclient
   from ldclient.config import Config
   
   ldclient.set_config(Config("{sdk_key}"))
   # SDK initializes successfully
   
   # Always flush events before closing — trailing events are at risk of being
   # lost otherwise, in short-lived scripts and long-running services alike.
   ldclient.get().flush()
   ldclient.get().close()

3. Report results:
   • ✓ Project exists and has environments
   • ✓ SDK keys are present and valid
   • ✓ SDK can initialize (or flag any issues)

Project Key Best Practices

✓ Good examples:
  - "support-ai"
  - "chat-bot-v2"
  - "internal-tools"

✗ Bad examples:
  - "Support_AI"     # No uppercase or underscores
  - "123-project"    # Must start with letter  
  - "my.project"     # No dots allowed

• Keep keys short but descriptive
• Use team/service/purpose as naming scheme
• Be consistent across your organization

Common Organization Patterns

By Team

platform-ai       → Platform Team Agent
customer-ai       → Customer Success Team Agent
internal-ai       → Internal Tools Team Agent

By Application/Service

mobile-ai         → Mobile App configs
web-ai            → Web App configs
api-ai            → API Service configs

By Region/Deployment

ai-us             → US Region
ai-eu             → Europe Region
ai-apac           → Asia-Pacific Region

Edge Cases

projects:write

What NOT to Do

• Don't create projects without understanding the use case first
• Don't commit API tokens or SDK keys to version control
• Don't use production SDK keys in test/development environments
• Don't create duplicate projects unnecessarily
• Don't skip the exploration phase

Next Steps

1. Create configs - Use the

   configs-create

   skill
2. Set up SDK Integration - Use the

   sdk

   skill
3. Configure Targeting - Use the

   configs-targeting

   skill

Related Skills

• configs-create

  - Create configs in projects

• sdk

  - Integrate SDK in your application

• configs-targeting

  - Configure config targeting

• configs-variations

  - Manage config variations

References

• Python Implementation
• Node.js Implementation
• Go Implementation
• Quick Start Guide
• Environment Configuration
• Project Cloning
• IaC/Automation
• Admin Tooling