> ## Documentation Index
> Fetch the complete documentation index at: https://ulpi.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Getting Started

> Set up ULPI Skills and start generating consistent code in 10 minutes

## Your AI Will Follow Your Patterns in 10 Minutes

No complex configuration. No long setup process. Just 3 simple steps.

<Info>
  **Time estimate:** 10 minutes

  **Prerequisites:**

  * ULPI account ([sign up free](https://app.ulpi.io/register))
  * Repository with code
  * AI assistant with MCP support (Claude Desktop, Cursor, etc.)
</Info>

***

## Step 1: Connect Your Repository

<Steps>
  <Step title="Navigate to Repositories">
    **Dashboard** → **Repositories** → Click **Connect Repository**

    <Info>
      **Pro tip:** Connect your most active repository first
    </Info>
  </Step>

  <Step title="Choose Your Git Provider">
    * **GitHub** (most common)
    * **GitLab** (cloud or self-hosted)
    * **Bitbucket** (cloud or server)
    * **Gitea** (self-hosted)

    <Check>
      **Read-only access:** ULPI only needs read permissions to detect your tech stack
    </Check>
  </Step>

  <Step title="Authorize ULPI">
    Grant ULPI access to:

    * ✅ Read repository contents
    * ✅ Detect technologies (package.json, composer.json, etc.)
    * ❌ **No write access** required

    **We DO NOT:**

    * Write to your repositories
    * Execute code
    * Store your source code
  </Step>

  <Step title="Tech Stack Auto-Detection">
    ULPI automatically detects your technologies:

    **Scans:**

    * `package.json` → Node.js, React, Next.js
    * `composer.json` → PHP, Laravel
    * `requirements.txt` → Python, Django, FastAPI
    * `pom.xml` → Java, Spring Boot
    * File extensions → Languages, frameworks

    **Result:**

    ```
    ✅ Detected Technologies:
    - PHP 8.2
    - Laravel 11
    - MySQL 8.0
    - Redis 7.0
    - Docker

    Skills matched: 8 public skills
    ```
  </Step>
</Steps>

**⏱️ Time:** 2 minutes

***

## Step 2: Configure Your AI Assistant

<Tabs>
  <Tab title="Claude Desktop">
    **Add ULPI Skills MCP server:**

    1. Open Claude Desktop settings
    2. Navigate to **Developer** → **MCP Servers**
    3. Click **Add Server**
    4. Use these settings:

    ```json theme={null}
    {
      "ulpi-skills": {
        "command": "npx",
        "args": [
          "@ulpi/mcp-client",
          "skills"
        ],
        "env": {
          "ULPI_API_KEY": "your-api-key-here",
          "ULPI_PROJECT_ID": "your-project-id"
        }
      }
    }
    ```

    5. **Get your API key:**
       * Dashboard → **Settings** → **API Keys** → **Create Key**
       * Select scope: **Skills**

    6. **Get your Project ID:**
       * Dashboard → Select project → URL shows `/projects/123` (123 is your ID)

    7. Restart Claude Desktop

    <Check>
      **Verify:** Start a new chat. Ask: "What skills are available?"

      Claude should list your matched skills.
    </Check>
  </Tab>

  <Tab title="Cursor">
    **Add ULPI Skills to Cursor:**

    1. Open Cursor settings (Cmd+, or Ctrl+,)
    2. Go to **Features** → **MCP**
    3. Add new MCP server:

    ```json theme={null}
    {
      "name": "ULPI Skills",
      "command": "npx",
      "args": [
        "@ulpi/mcp-client",
        "skills"
      ],
      "env": {
        "ULPI_API_KEY": "your-api-key-here",
        "ULPI_PROJECT_ID": "your-project-id"
      }
    }
    ```

    4. Reload Cursor (Cmd+Shift+P → "Reload Window")

    <Info>
      **Get credentials:** Dashboard → Settings → API Keys (create new key + copy project ID from URL)
    </Info>
  </Tab>

  <Tab title="Windsurf">
    **Connect Windsurf to ULPI Skills:**

    1. Open Windsurf settings
    2. Navigate to **Extensions** → **MCP Configuration**
    3. Add ULPI Skills:

    ```json theme={null}
    {
      "mcpServers": {
        "ulpi-skills": {
          "command": "npx",
          "args": ["@ulpi/mcp-client", "skills"],
          "env": {
            "ULPI_API_KEY": "your-api-key-here",
            "ULPI_PROJECT_ID": "your-project-id"
          }
        }
      }
    }
    ```

    4. Restart Windsurf
  </Tab>

  <Tab title="Other AI Tools (29+)">
    **ULPI Skills works with any MCP-compatible AI assistant:**

    * Claude Code
    * VSCode Copilot
    * Zed
    * Cline
    * Continue
    * Aider
    * And 24+ more...

    **Generic setup:**

    1. Find MCP configuration in your AI tool's settings
    2. Add ULPI Skills MCP server with command:
       ```bash theme={null}
       npx @ulpi/mcp-client skills
       ```
    3. Set environment variables:
       * `ULPI_API_KEY` (from Dashboard → Settings → API Keys)
       * `ULPI_PROJECT_ID` (from project URL)

    <Info>
      **Need help?** Check our [MCP setup guide](/skills/mcp-setup) or email [support@ulpi.io](mailto:support@ulpi.io)
    </Info>
  </Tab>
</Tabs>

**⏱️ Time:** 5 minutes

***

## Step 3: Use Your First Skill

<Tabs>
  <Tab title="Discover Available Skills">
    **Ask your AI:**

    ```
    You: "What skills are available for this project?"
    ```

    **AI response:**

    ```
    I have access to 8 ULPI Skills for your Laravel project:

    1. Create Laravel API Endpoint
       Build RESTful APIs with validation, resources, tests

    2. Laravel Database Migration
       Design schemas with proper types, indexes

    3. Write PHPUnit Tests
       Create feature and unit tests with mocks

    4. Implement Laravel Queue Job
       Build async jobs with retry logic

    5. Database Query Optimization
       Fix slow queries, add indexes, prevent N+1

    6. Git Commit Best Practices
       Write professional commit messages

    7. API Documentation with OpenAPI
       Document REST APIs with OpenAPI 3.0

    8. Setup Docker Container
       Containerize your Laravel application

    Would you like me to use one?
    ```
  </Tab>

  <Tab title="Use a Skill">
    **Ask your AI to use a skill:**

    ```
    You: "Use the Create Laravel API Endpoint skill to build /api/posts"
    ```

    **AI executes the skill:**

    ```
    Following the Create Laravel API Endpoint skill...

    ✅ Step 1: Creating FormRequest validation
       Created: app/Http/Requests/StorePostRequest.php

    ✅ Step 2: Building API Resource transformation
       Created: app/Http/Resources/PostResource.php

    ✅ Step 3: Implementing Service layer logic
       Created: app/Services/PostService.php

    ✅ Step 4: Creating API Controller
       Created: app/Http/Controllers/API/PostController.php

    ✅ Step 5: Adding routes with rate limiting
       Updated: routes/api.php (5 new routes)

    ✅ Step 6: Writing feature tests
       Created: tests/Feature/PostControllerTest.php (12 tests)

    Complete! Generated 6 files, all tests passing.
    ```

    <Check>
      **Result:** Production-ready code in 2 minutes, zero rework needed
    </Check>
  </Tab>

  <Tab title="Review Generated Code">
    **Check what was created:**

    ```bash theme={null}
    # Validation
    app/Http/Requests/StorePostRequest.php
    - Title required, max 255 chars
    - Content required
    - Published_at date format validation

    # Transformation
    app/Http/Resources/PostResource.php
    - Consistent JSON formatting
    - Related data included
    - Timestamps formatted

    # Business Logic
    app/Services/PostService.php
    - CRUD operations
    - Transaction support
    - Error handling

    # Controller
    app/Http/Controllers/API/PostController.php
    - index(), store(), show(), update(), destroy()
    - Proper HTTP status codes
    - Resource responses

    # Routes
    routes/api.php
    - GET /api/posts
    - POST /api/posts
    - GET /api/posts/{id}
    - PUT /api/posts/{id}
    - DELETE /api/posts/{id}
    - Rate limiting: 60 requests/minute

    # Tests
    tests/Feature/PostControllerTest.php
    - 12 tests covering all endpoints
    - Database factories used
    - Edge cases tested
    ```

    **All code follows Laravel best practices** ✅
  </Tab>
</Tabs>

**⏱️ Time:** 2 minutes

***

## ✅ You're Done! What's Next?

<CardGroup cols={2}>
  <Card title="Try More Skills" icon="sparkles">
    ```
    "Use the Write PHPUnit Tests skill to add tests for UserController"

    "Use the Laravel Database Migration skill to add posts table"

    "Use the Git Commit Best Practices skill to commit these changes"
    ```

    Explore all 8 skills matched to your project
  </Card>

  <Card title="Create Custom Skill" icon="plus">
    Encode your team's patterns:

    * Your deployment workflow
    * Company coding standards
    * Code review checklist
    * Security scanning process

    [Learn How to Create Custom Skills →](/skills/custom-skills)
  </Card>

  <Card title="View in Dashboard" icon="table">
    **Dashboard** → Your Project → **Skills**

    * See all available skills
    * View skill details
    * Check usage statistics
    * Manage active skills
  </Card>

  <Card title="Integrate with Workflow" icon="sitemap">
    Combine skills for complete workflows:

    ```
    1. "Use Laravel API Endpoint skill for /api/users"
    2. "Use Write PHPUnit Tests skill for UserController"
    3. "Use API Documentation skill to document /api/users"
    4. "Use Git Commit Best Practices skill to commit"
    ```

    [See Common Workflows →](#common-workflows)
  </Card>
</CardGroup>

***

## Common Workflows

<AccordionGroup>
  <Accordion title="🔌 API Development Workflow" icon="code">
    **Complete API feature in 10 minutes:**

    **Step 1: Create endpoint**

    ```
    "Use Create Laravel API Endpoint skill for /api/posts"
    ```

    → Generates controller, validation, resource, service, routes, tests

    **Step 2: Add tests**

    ```
    "Use Write PHPUnit Tests skill to add edge case tests"
    ```

    → Adds authorization tests, validation tests, error handling

    **Step 3: Document API**

    ```
    "Use API Documentation with OpenAPI skill for /api/posts"
    ```

    → Generates OpenAPI spec, example requests/responses

    **Step 4: Commit**

    ```
    "Use Git Commit Best Practices skill to commit these changes"
    ```

    → Creates proper commit message following Conventional Commits

    **Result:**

    * Complete API endpoint
    * 100% test coverage
    * Full documentation
    * Professional commit message
    * **Time:** 10 minutes (vs. 2 hours manually)
  </Accordion>

  <Accordion title="🗄️ Database Schema Workflow" icon="database">
    **Add new database table:**

    **Step 1: Create migration**

    ```
    "Use Laravel Database Migration skill to add posts table with:
     - title (string, required)
     - content (text)
     - published_at (timestamp, nullable)
     - user_id (foreign key to users)"
    ```

    → Generates migration with proper types, indexes, foreign keys

    **Step 2: Create model and relationships**

    ```
    "Create Post model with relationships to User"
    ```

    → Generates model with fillable, casts, relationships

    **Step 3: Add factory and seeder**

    ```
    "Create factory and seeder for Post model"
    ```

    → Generates realistic test data

    **Step 4: Test migration**

    ```
    "Use Write PHPUnit Tests skill to test Post migration"
    ```

    → Creates migration tests, relationship tests

    **Result:**

    * Production-ready schema
    * Proper indexes for performance
    * Test data generation
    * Migration tests
  </Accordion>

  <Accordion title="⚛️ React Component Workflow" icon="atom">
    **Build new UI component:**

    **Step 1: Create component**

    ```
    "Use Create React Component skill for UserProfile with:
     - Props: user, onEdit, onDelete
     - Show avatar, name, email, role
     - Edit and delete buttons"
    ```

    → Generates component, TypeScript types, CSS module, tests, story

    **Step 2: Add to Storybook** (if you have custom skill)

    ```
    "Use Add Component to Storybook skill for UserProfile"
    ```

    → Creates Storybook stories with all variants

    **Step 3: Test accessibility**

    ```
    "Add accessibility tests for UserProfile component"
    ```

    → Adds ARIA label tests, keyboard navigation tests

    **Step 4: Commit**

    ```
    "Use Git Commit Best Practices skill to commit UserProfile"
    ```

    **Result:**

    * Production-ready component
    * Full TypeScript types
    * Component tests
    * Storybook documentation
    * Accessibility compliant
  </Accordion>

  <Accordion title="🚀 Deployment Workflow" icon="rocket">
    **Deploy to staging (custom skill example):**

    **Prerequisites:** Create custom "Deploy to Staging" skill

    **Usage:**

    ```
    "Use Deploy to Staging skill"
    ```

    **Skill executes:**

    ```
    ✅ Step 1: Running test suite
       All 247 tests passing

    ✅ Step 2: Building production assets
       Built in 23.4s

    ✅ Step 3: Creating deployment branch
       Branch: deploy/staging-20250112

    ✅ Step 4: Pushing to staging
       Pushed to staging remote

    ✅ Step 5: Running database migrations
       Migrated 3 new migrations

    ✅ Step 6: Verifying deployment
       Health check: OK (200)

    ✅ Step 7: Notifying team
       Posted to #deployments channel

    Deployment complete! Staging is live.
    ```

    **Result:**

    * Zero mistakes
    * Every step verified
    * Team notified
    * **Time:** 3 minutes (vs. 20 minutes manually)
  </Accordion>

  <Accordion title="🔍 Code Review Workflow" icon="magnifying-glass">
    **Before creating PR (custom skill):**

    **Prerequisites:** Create custom "Pre-Review Checklist" skill

    **Usage:**

    ```
    "Use Pre-Review Checklist skill before creating PR"
    ```

    **Skill checks:**

    ```
    ✅ Tests Pass
       247/247 tests passing
       Coverage: 87%

    ✅ Code Quality
       Linter: Passed
       No console.logs found
       No commented code

    ✅ Security
       No hardcoded secrets
       SQL injection: Protected
       XSS protection: Enabled

    ✅ Documentation
       README updated
       API docs current
       Changelog entry added

    ✅ Performance
       No N+1 queries detected
       Images optimized
       Bundle size: 234KB (under 250KB limit)

    All checks passed! Ready to create PR.
    ```

    **Result:**

    * 78% reduction in code review iterations
    * Faster PR approvals
    * Higher code quality
  </Accordion>
</AccordionGroup>

***

## Troubleshooting

<AccordionGroup>
  <Accordion title="❌ Skills Not Showing in AI Assistant" icon="triangle-exclamation">
    **Problem:** AI says "No skills available"

    **Diagnosis:**

    1. **Check MCP connection:**
       * Restart your AI assistant
       * Start new chat
       * Ask: "What MCP servers are connected?"

    2. **Verify API key:**
       ```json theme={null}
       // Check your config
       "env": {
         "ULPI_API_KEY": "sk_..."  // Must start with sk_
       }
       ```
       * Dashboard → Settings → API Keys → Verify key is active

    3. **Verify project ID:**
       ```json theme={null}
       "ULPI_PROJECT_ID": "123"  // Numeric ID from URL
       ```
       * Dashboard → Select project → Check URL

    4. **Check API key scope:**
       * API key must have **Skills** scope enabled
       * Dashboard → Settings → API Keys → Check scopes

    **Fix:**

    * Correct API key or project ID in MCP config
    * Restart AI assistant
    * Test: "What skills are available?"
  </Accordion>

  <Accordion title="❌ Wrong Skills Showing" icon="filter">
    **Problem:** Seeing Laravel skills in React project (or vice versa)

    **Cause:** Tech stack not detected correctly

    **Fix:**

    1. **Check detected technologies:**
       * Dashboard → Your Project → **Tech Stack**

    2. **Manually add missing technologies:**
       * Click **Edit Tech Stack**
       * Add: React, TypeScript, Node.js, etc.
       * Save

    3. **Reconnect repository:**
       * Sometimes helps re-trigger detection
       * Dashboard → Repositories → Disconnect → Reconnect

    4. **Verify package files exist:**
       * React projects need `package.json` with `react` dependency
       * Laravel projects need `composer.json` with `laravel/framework`

    **Result:** Skills filtered correctly for your stack
  </Accordion>

  <Accordion title="❌ Skill Run Failed" icon="circle-exclamation">
    **Problem:** AI says "Skill execution failed"

    **Common causes:**

    **1. Missing dependencies:**

    ```
    Error: "Laravel not installed"
    ```

    → Skill requires Laravel, but project is not Laravel

    **2. Invalid parameters:**

    ```
    Error: "Invalid endpoint format"
    ```

    → Check skill requirements (e.g., endpoint must start with /)

    **3. Quota exceeded:**

    ```
    Error: "Skill run limit exceeded"
    ```

    → Upgrade plan or wait for monthly reset

    **4. File conflicts:**

    ```
    Error: "File already exists: PostController.php"
    ```

    → Skill tries to create existing file

    **Fix:**

    * Read error message carefully
    * Check skill prerequisites
    * Verify project structure
    * Ask AI to retry with corrections
  </Accordion>

  <Accordion title="🔍 How to See Skill Details" icon="magnifying-glass">
    **In Dashboard:**

    1. Dashboard → Your Project → **Skills**
    2. Click on skill name
    3. View:
       * Full skill description
       * Step-by-step guide
       * Prerequisites
       * Example usage
       * Related skills

    **In AI Assistant:**

    ```
    "Explain the Create Laravel API Endpoint skill"
    ```

    AI will show:

    * What the skill does
    * What files it creates
    * Prerequisites
    * Example usage
  </Accordion>

  <Accordion title="📊 Check Usage Statistics" icon="chart-simple">
    **View your usage:**

    1. Dashboard → **Billing** → **Usage**

    **Shows:**

    * Skill runs this month
    * Runs by skill (which skills used most)
    * Tokens consumed
    * Remaining quota

    **Example:**

    ```
    January 2025 Usage:

    Skill Runs: 247 / 1,000 (24%)
    - Create Laravel API Endpoint: 89 runs
    - Write PHPUnit Tests: 67 runs
    - Laravel Database Migration: 45 runs
    - Git Commit Best Practices: 46 runs

    Tokens: 125,430 / 50,000 (exceeded, $3.78 overage)

    Projected monthly cost: $19.00 + $3.78 = $22.78
    ```

    **Tip:** Upgrade to Pro if consistently exceeding limits
  </Accordion>
</AccordionGroup>

***

## Quick Reference

<Tabs>
  <Tab title="Essential Commands">
    ```bash theme={null}
    # Discover skills
    "What skills are available?"
    "List all Laravel skills"
    "Explain the [skill name] skill"

    # Use skills
    "Use the [skill name] skill to [task]"
    "Use Create Laravel API Endpoint skill for /api/users"

    # Create custom skills
    "How do I create a custom skill?"
    [See Custom Skills guide]

    # Check usage
    "How many skill runs have I used this month?"
    [Check in Dashboard → Billing → Usage]
    ```
  </Tab>

  <Tab title="MCP Configuration">
    ```json theme={null}
    {
      "ulpi-skills": {
        "command": "npx",
        "args": ["@ulpi/mcp-client", "skills"],
        "env": {
          "ULPI_API_KEY": "sk_your_key_here",
          "ULPI_PROJECT_ID": "123"
        }
      }
    }
    ```

    **Get credentials:**

    * API Key: Dashboard → Settings → API Keys → Create Key (Skills scope)
    * Project ID: Dashboard → Select project → URL `/projects/123`
  </Tab>

  <Tab title="Public Skills (10)">
    **Laravel:**

    1. Create Laravel API Endpoint
    2. Laravel Database Migration
    3. Write PHPUnit Tests
    4. Implement Laravel Queue Job
    5. Database Query Optimization

    **React:**
    6\. Create React Component
    7\. Create REST API Client

    **Universal:**
    8\. Git Commit Best Practices
    9\. API Documentation with OpenAPI
    10\. Setup Docker Container

    **288+ technologies supported**
  </Tab>

  <Tab title="Pricing & Limits">
    ```
    Starter ($19/month):
    - 5 active skills
    - 1,000 skill runs/month
    - 50,000 tokens
    - $0.05 per additional run

    Pro ($69/month):
    - 25 active skills
    - 10,000 skill runs/month
    - 300,000 tokens
    - $0.02 per additional run

    Enterprise ($199/month):
    - Unlimited skills
    - Unlimited runs
    - 1,000,000 tokens
    - Dedicated support
    ```
  </Tab>
</Tabs>

***

## What's Next?

<Steps>
  <Step title="Explore All Skills">
    Ask your AI: "Show me all available skills with examples"
  </Step>

  <Step title="Learn How Skills Work">
    [Technical deep dive](/skills/how-skills-work) into skill execution and token usage
  </Step>

  <Step title="Create Custom Skills">
    [Encode your team's patterns](/skills/custom-skills) into reusable workflows
  </Step>

  <Step title="Optimize Your Workflow">
    Combine skills for end-to-end workflows (API → Tests → Docs → Commit)
  </Step>
</Steps>

***

## Need Help?

<CardGroup cols={3}>
  <Card title="Documentation" icon="book" href="/skills/how-skills-work">
    Technical guides
  </Card>

  <Card title="Support" icon="life-ring" href="mailto:support@ulpi.io">
    Email us anytime
  </Card>

  <Card title="Community" icon="discord" href="https://discord.gg/ulpi">
    Join our Discord
  </Card>
</CardGroup>