> ## 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.

# Tech Stack Matching

> How ULPI detects your technologies and matches skills to your repository

<Tabs>
  <Tab title="Before ULPI Tech Stack Matching">
    **Your AI sees every skill—even irrelevant ones:**

    * ❌ Laravel repo sees React Component skill (not applicable)
    * ❌ React repo sees Laravel Queue Job skill (not applicable)
    * ❌ Python repo sees PHP-specific skills (not applicable)
    * ❌ Overwhelming list of 50+ irrelevant options
    * ❌ AI wastes time reading skills that don't apply
    * ❌ 2 minutes lost per task finding the right skill
    * ❌ Risk of AI using wrong skill for your tech stack
  </Tab>

  <Tab title="After ULPI Tech Stack Matching">
    **Your AI sees only skills that match your technologies:**

    * ✅ Laravel repo sees Laravel API, Laravel Migration, Laravel Queue, PHPUnit Tests
    * ✅ React repo sees React Component, REST API Client, TypeScript skills
    * ✅ Python repo sees Python-specific skills only
    * ✅ Clean, focused list of 5-12 relevant skills
    * ✅ AI instantly finds the right skill for the job
    * ✅ Zero time wasted on irrelevant options
    * ✅ 100% confidence AI uses correct patterns for your stack
  </Tab>
</Tabs>

<Check>
  **Customer Success Story:**

  "Our monorepo has Laravel backend + React frontend. Without tech stack matching, our AI would see 40+ skills—half of them irrelevant. Now it sees exactly 14 skills: 8 Laravel skills and 6 React skills. Our developers find the right skill in 5 seconds instead of 2 minutes." — **Engineering Manager, FinTech Platform with 200K Users**
</Check>

***

## Why Tech Stack Matching Matters

Tech stack matching is ULPI's intelligent filtering system that ensures your AI assistant only sees skills relevant to your repository's technologies.

<CardGroup cols={2}>
  <Card title="Reduce Noise" icon="filter">
    See only skills that apply to your tech stack. No PHP skills in Python repos, no React skills in Laravel-only projects.
  </Card>

  <Card title="Save Time" icon="clock">
    Find the right skill in 5 seconds instead of 2 minutes. AI doesn't waste time reading irrelevant skills.
  </Card>

  <Card title="Prevent Errors" icon="shield-check">
    AI can't accidentally use Laravel patterns in a Django project. Stack-specific skills enforce correct patterns.
  </Card>

  <Card title="Scale Gracefully" icon="chart-line">
    As you add more skills, filtering keeps your skill list manageable. 100 total skills → 10 relevant skills per repo.
  </Card>
</CardGroup>

### Real-World Example

**Repository**: Laravel 12.x + React + MySQL + Redis

**Without Tech Stack Matching:**

* 40 skills shown (all public + custom skills)
* Includes Django, Vue.js, .NET, Angular skills (not applicable)
* Developer spends 2 minutes scrolling to find Laravel API skill
* Risk of AI using wrong pattern (e.g., Django ORM instead of Eloquent)

**With Tech Stack Matching:**

* 14 skills shown (only matching technologies)
* ✅ Create Laravel API Endpoint (PHP, Laravel)
* ✅ Laravel Database Migration (PHP, Laravel, MySQL)
* ✅ Implement Laravel Queue Job (PHP, Laravel, Redis)
* ✅ Write PHPUnit Tests (PHP, Laravel)
* ✅ Create React Component (JavaScript, React)
* ✅ Setup Docker Container (Universal—no filter)
* ✅ Git Commit Best Practices (Universal—no filter)
* ✅ Database Query Optimization (MySQL)
* ❌ Django-specific skills (filtered out)
* ❌ Vue.js-specific skills (filtered out)
* ❌ .NET-specific skills (filtered out)

**Time Saved**: 1 minute 55 seconds per skill search × 20 skill uses/day = **38 minutes saved daily**

***

## How Tech Stack Detection Works

ULPI automatically detects your repository's technologies through a **5-step analysis process** when you connect a repository.

### Step 1: Package Manager Analysis

ULPI scans package manager files to identify your dependencies and frameworks.

<Tabs>
  <Tab title="JavaScript/TypeScript">
    **File**: `package.json`

    ```json theme={null}
    {
      "dependencies": {
        "react": "^18.2.0",           // → React detected
        "next": "^14.0.0",            // → Next.js detected
        "typescript": "^5.0.0",       // → TypeScript detected
        "@nestjs/core": "^10.0.0"     // → NestJS detected
      }
    }
    ```

    **Detected Technologies**: React, Next.js, TypeScript, NestJS, Node.js
  </Tab>

  <Tab title="PHP">
    **File**: `composer.json`

    ```json theme={null}
    {
      "require": {
        "laravel/framework": "^12.0", // → Laravel detected
        "php": "^8.2",                // → PHP detected
        "predis/predis": "^2.0",      // → Redis detected
        "laravel/sanctum": "^4.0"     // → Laravel Sanctum detected
      }
    }
    ```

    **Detected Technologies**: PHP, Laravel, Redis, Laravel Sanctum
  </Tab>

  <Tab title="Python">
    **File**: `requirements.txt`

    ```txt theme={null}
    Django==5.0.0         # → Django detected
    fastapi==0.104.0      # → FastAPI detected
    redis==5.0.0          # → Redis detected
    sqlalchemy==2.0.0     # → SQLAlchemy detected
    ```

    **Detected Technologies**: Python, Django, FastAPI, Redis, SQLAlchemy
  </Tab>

  <Tab title="Java">
    **File**: `pom.xml`

    ```xml theme={null}
    <dependencies>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <!-- → Spring Boot detected -->
      </dependency>
    </dependencies>
    ```

    **Detected Technologies**: Java, Spring Boot, Maven
  </Tab>
</Tabs>

### Step 2: Configuration File Detection

ULPI looks for framework-specific configuration files to confirm technology presence.

<AccordionGroup>
  <Accordion title="Laravel Detection" icon="php">
    **Marker Files**:

    * `artisan` (Laravel CLI file)
    * `bootstrap/app.php`
    * `config/app.php`
    * `routes/web.php`
    * `app/Models/` directory

    **Result**: Confirms Laravel framework usage
  </Accordion>

  <Accordion title="React Detection" icon="react">
    **Marker Files**:

    * `jsconfig.json` or `tsconfig.json`
    * `.babelrc` or `babel.config.js`
    * `webpack.config.js` or `vite.config.js`
    * `src/components/` directory
    * `public/index.html`

    **Result**: Confirms React framework usage
  </Accordion>

  <Accordion title="Docker Detection" icon="docker">
    **Marker Files**:

    * `Dockerfile`
    * `docker-compose.yml`
    * `.dockerignore`

    **Result**: Confirms Docker containerization
  </Accordion>

  <Accordion title="Database Detection" icon="database">
    **Marker Files**:

    * `.env` with `DB_CONNECTION=mysql`
    * `knexfile.js`
    * `migrate.config.js`
    * `database/migrations/` directory

    **Result**: Confirms database usage (MySQL, PostgreSQL, etc.)
  </Accordion>
</AccordionGroup>

### Step 3: Language Detection

ULPI counts file extensions to determine primary and secondary languages.

**Example Analysis**:

```typescript theme={null}
{
  ".php": 150 files,        // → PHP (primary language)
  ".js": 45 files,          // → JavaScript (secondary)
  ".vue": 30 files,         // → Vue.js (detected)
  ".ts": 12 files,          // → TypeScript (detected)
  ".py": 5 files,           // → Python (minimal usage)
  ".go": 0 files            // → Not detected
}
```

**Result**: PHP (primary), JavaScript, Vue.js, TypeScript

### Step 4: Framework Marker Detection

ULPI identifies framework-specific directory structures.

<Tabs>
  <Tab title="Laravel">
    ```
    app/Models/              → Eloquent models
    app/Http/Controllers/    → Laravel controllers
    database/migrations/     → Laravel migrations
    resources/views/         → Blade templates
    routes/web.php           → Laravel routing
    ```

    **Result**: Laravel framework confirmed
  </Tab>

  <Tab title="React">
    ```
    src/components/          → React components
    src/hooks/               → Custom hooks
    src/App.jsx              → Main app component
    public/index.html        → React entry point
    ```

    **Result**: React framework confirmed
  </Tab>

  <Tab title="Django">
    ```
    manage.py               → Django CLI
    settings.py             → Django settings
    urls.py                 → URL routing
    models.py               → Django models
    ```

    **Result**: Django framework confirmed
  </Tab>

  <Tab title="Next.js">
    ```
    pages/                  → Next.js pages (old structure)
    app/                    → Next.js app router (new structure)
    next.config.js          → Next.js configuration
    public/                 → Static assets
    ```

    **Result**: Next.js framework confirmed
  </Tab>
</Tabs>

### Step 5: Tool Detection

ULPI identifies DevOps and infrastructure tools used in your project.

<CardGroup cols={2}>
  <Card title="Docker" icon="docker">
    **Files**:

    * `Dockerfile` exists
    * `docker-compose.yml` exists

    **Result**: Docker detected
  </Card>

  <Card title="Git" icon="git">
    **Files**:

    * `.git/` directory
    * `.gitignore` file

    **Result**: Git detected (always)
  </Card>

  <Card title="GitHub Actions" icon="github">
    **Files**:

    * `.github/workflows/` directory
    * `.github/workflows/*.yml` files

    **Result**: GitHub Actions detected
  </Card>

  <Card title="GitLab CI" icon="gitlab">
    **Files**:

    * `.gitlab-ci.yml` exists

    **Result**: GitLab CI detected
  </Card>

  <Card title="Jenkins" icon="jenkins">
    **Files**:

    * `Jenkinsfile` exists

    **Result**: Jenkins detected
  </Card>

  <Card title="CircleCI" icon="circle">
    **Files**:

    * `.circleci/config.yml` exists

    **Result**: CircleCI detected
  </Card>
</CardGroup>

***

## Supported Technologies (288+)

ULPI supports **288+ technologies** organized into ecosystems. Your skills are automatically filtered based on detected technologies.

### Programming Languages (15+)

<Tabs>
  <Tab title="Backend Languages">
    * **PHP** (Laravel ecosystem)
    * **Python** (Django, FastAPI)
    * **Ruby** (Rails)
    * **Go** (Gin, Echo)
    * **Rust** (Actix, Rocket)
    * **Java** (Spring Boot)
    * **C#** (ASP.NET Core)
    * **Kotlin** (Spring, Ktor)
    * **Scala** (Play Framework)
  </Tab>

  <Tab title="Frontend Languages">
    * **JavaScript** (React, Vue, Angular)
    * **TypeScript** (Next.js, Nest.js)
    * **CoffeeScript** (legacy)
    * **Dart** (Flutter)
    * **Elm** (functional UI)
  </Tab>

  <Tab title="Mobile Languages">
    * **Swift** (iOS)
    * **Objective-C** (iOS)
    * **Kotlin** (Android)
    * **Dart** (Flutter)
  </Tab>
</Tabs>

### Backend Frameworks (45+)

<AccordionGroup>
  <Accordion title="PHP Frameworks (31 items)" icon="php">
    **Core Frameworks**:

    * Laravel, Lumen
    * Symfony
    * CodeIgniter
    * Yii, Phalcon

    **Laravel Ecosystem**:

    * Livewire, Inertia.js
    * Laravel Sanctum (API authentication)
    * Laravel Cashier (billing)
    * Laravel Horizon (queue monitoring)
    * Laravel Scout (search)
    * Laravel Telescope (debugging)
    * Laravel Passport (OAuth)
    * Laravel Socialite (social auth)
    * Laravel Pail (log viewer)
    * Laravel Vapor (serverless)
    * Laravel Octane (performance)
    * Laravel Sail (Docker dev)
    * Laravel Fortify (authentication)
    * Laravel Jetstream (starter kit)
    * Laravel Breeze (authentication)
    * Laravel Pulse (monitoring)
    * Laravel Prompts (CLI)
    * Laravel Pennant (feature flags)
    * Laravel Reverb (WebSockets)
    * Laravel Folio (page routing)
  </Accordion>

  <Accordion title="Node.js Frameworks (35+ items)" icon="node">
    **Backend Frameworks**:

    * Express.js (most popular)
    * NestJS (enterprise)
    * Fastify (performance)
    * Koa (modern)
    * Hapi (configuration-driven)

    **Full-Stack Frameworks**:

    * Next.js (React)
    * Nuxt.js (Vue)
    * SvelteKit (Svelte)
    * Remix (React)
  </Accordion>

  <Accordion title="Python Frameworks" icon="python">
    * Django (full-stack)
    * FastAPI (modern API)
    * Flask (micro-framework)
    * Pyramid (flexible)
    * Tornado (async)
  </Accordion>

  <Accordion title="Other Backend Frameworks" icon="server">
    * **Spring Boot** (Java)
    * **ASP.NET Core** (C#)
    * **Ruby on Rails** (Ruby)
    * **Phoenix** (Elixir)
    * **Gin, Echo** (Go)
    * **Actix, Rocket** (Rust)
  </Accordion>
</AccordionGroup>

### Frontend Frameworks (46+)

<AccordionGroup>
  <Accordion title="React Ecosystem (46 items)" icon="react">
    **Core Framework**:

    * React

    **Routing**:

    * React Router
    * TanStack Router

    **State Management**:

    * Redux, Redux Toolkit
    * Zustand
    * Jotai
    * Recoil
    * MobX

    **Data Fetching**:

    * React Query (TanStack Query)
    * SWR
    * RTK Query

    **Forms**:

    * React Hook Form
    * Formik

    **Testing**:

    * React Testing Library
    * Jest
    * Vitest

    **Styling**:

    * Styled Components
    * Emotion
    * CSS Modules
    * Tailwind CSS

    **UI Libraries**:

    * Material-UI (MUI)
    * Ant Design
    * Chakra UI
    * Shadcn UI

    **Animation**:

    * Framer Motion
    * React Spring

    **Mobile**:

    * React Native
    * Expo
  </Accordion>

  <Accordion title="Other Frontend Frameworks" icon="window">
    * **Vue.js**, Nuxt.js
    * **Angular**
    * **Svelte**, SvelteKit
    * **Solid.js**
    * **Ember.js**
    * **Preact**
  </Accordion>
</AccordionGroup>

### Databases (25+)

<Tabs>
  <Tab title="Relational">
    * **MySQL** (most popular)
    * **PostgreSQL** (advanced)
    * **MariaDB**
    * **SQLite**
    * **Oracle**
    * **SQL Server**
  </Tab>

  <Tab title="NoSQL">
    * **MongoDB** (document)
    * **Redis** (in-memory)
    * **DynamoDB** (AWS)
    * **Cassandra** (wide-column)
    * **CouchDB** (document)
    * **Neo4j** (graph)
  </Tab>

  <Tab title="Search Engines">
    * **Elasticsearch**
    * **Typesense**
    * **Algolia**
    * **MeiliSearch**
  </Tab>

  <Tab title="In-Memory">
    * **Redis**
    * **Memcached**
  </Tab>
</Tabs>

### DevOps & CI/CD (48+)

**Containerization**:

* Docker, Kubernetes, Docker Compose, Podman

**CI/CD Platforms**:

* GitHub Actions, GitLab CI, CircleCI, Jenkins, Travis CI, Azure DevOps

**Cloud Providers**:

* AWS (95 services), Google Cloud, Azure, DigitalOcean, Heroku, Vercel, Netlify

**Monitoring**:

* Sentry, Datadog, New Relic, Prometheus, Grafana

### Build Tools & Package Managers (30+)

**JavaScript**: npm, Yarn, pnpm, Webpack, Vite, Rollup, Babel, SWC, ESLint, Prettier

**PHP**: Composer, PHP CS Fixer, PHPStan, Psalm

**Python**: pip, Poetry, Pipenv, Black, Flake8

**Other**: Maven, Gradle (Java), Cargo (Rust), Go Modules

### Testing Frameworks (20+)

**PHP**: PHPUnit, Pest, Mockery

**JavaScript**: Jest, Vitest, Mocha, Chai, Cypress, Playwright, Testing Library

**Python**: pytest, unittest

***

## Skill Filtering Algorithm

Skills are filtered using a simple but powerful algorithm:

```typescript theme={null}
interface Skill {
  id: number;
  name: string;
  filters: string[];  // Tech stack slugs (e.g., ["php", "laravel"])
}

interface Repository {
  id: number;
  technologies: string[];  // Detected tech stack slugs
}

function filterSkills(repository: Repository, skills: Skill[]): Skill[] {
  return skills.filter(skill => {
    // Universal skills (no filters) are shown to everyone
    if (skill.filters.length === 0) {
      return true;
    }

    // Skill must match at least ONE repository technology
    return skill.filters.some(filter =>
      repository.technologies.includes(filter)
    );
  });
}
```

### Example Filtering

**Repository Technologies**: `["php", "laravel", "mysql", "redis"]`

<Tabs>
  <Tab title="Skill 1: Create Laravel API Endpoint">
    **Filters**: `["php", "laravel"]`

    **Match**: ✅ **Yes**

    **Reason**: Both `php` and `laravel` are in repository technologies
  </Tab>

  <Tab title="Skill 2: Create React Component">
    **Filters**: `["javascript", "react"]`

    **Match**: ❌ **No**

    **Reason**: Neither `javascript` nor `react` are in repository technologies
  </Tab>

  <Tab title="Skill 3: Git Commit Best Practices">
    **Filters**: `[]` (universal skill)

    **Match**: ✅ **Yes**

    **Reason**: Universal skills always shown (no filters)
  </Tab>

  <Tab title="Skill 4: Database Query Optimization">
    **Filters**: `["mysql", "postgresql"]`

    **Match**: ✅ **Yes**

    **Reason**: `mysql` is in repository technologies (OR logic)
  </Tab>
</Tabs>

***

## Universal Skills

Some skills apply to **all repositories** regardless of tech stack. These have **no filters** and are always shown.

**Universal Skills Examples**:

<CardGroup cols={2}>
  <Card title="Git Commit Best Practices" icon="git">
    Version control applies to all projects—PHP, Python, JavaScript, etc.
  </Card>

  <Card title="API Documentation with OpenAPI" icon="book">
    API documentation is language-agnostic. Works with Laravel, Django, Express, Spring Boot, etc.
  </Card>

  <Card title="Setup Docker Container" icon="docker">
    Containerization applies to all tech stacks. Docker works with any language/framework.
  </Card>

  <Card title="Database Query Optimization" icon="database">
    SQL optimization concepts are universal across MySQL, PostgreSQL, MariaDB, etc.
  </Card>
</CardGroup>

**Why Universal?**

* Core development practices (Git, documentation, testing)
* Infrastructure concerns (Docker, deployment, monitoring)
* Cross-cutting topics (performance, security, accessibility)

***

## Manually Adding Technologies

If ULPI doesn't automatically detect a technology, you can add it manually.

<Steps>
  <Step title="Navigate to Repository">
    In ULPI dashboard, go to **Repositories** → Select your repository
  </Step>

  <Step title="View Tech Stack Section">
    Scroll to **Technologies** section
  </Step>

  <Step title="Click Add Technology">
    Click **+ Add Technology** button
  </Step>

  <Step title="Search Technologies">
    Search from 288+ supported technologies:

    * Start typing (e.g., "Vue")
    * Select from dropdown
    * Multiple selections allowed
  </Step>

  <Step title="Save">
    Click **Save** to update your tech stack
  </Step>

  <Step title="Refresh Skills">
    Restart your IDE to clear MCP cache

    Skills will now be filtered with updated tech stack
  </Step>
</Steps>

**When to Manually Add**:

* Using a technology not in `package.json` (e.g., MySQL, Redis)
* Using a newer framework not yet auto-detected
* Using internal tools or custom frameworks
* Technology is in a subdirectory ULPI didn't scan

***

## Tech Stack Examples

Real-world repository configurations showing tech stack detection and skill filtering:

<Tabs>
  <Tab title="Full-Stack Laravel + React">
    ```json theme={null}
    {
      "repository": "my-saas-app",
      "detected_technologies": [
        // Backend
        "php", "laravel", "livewire", "inertia",
        "sanctum", "horizon", "telescope",
        // Frontend
        "javascript", "typescript", "react", "vite",
        "tailwindcss",
        // Database
        "mysql", "redis",
        // DevOps
        "docker", "docker-compose", "nginx",
        // Tools
        "git", "composer", "npm"
      ],
      "matched_skills": [
        "create-laravel-api-endpoint",
        "laravel-database-migration",
        "implement-laravel-queue-job",
        "write-phpunit-tests",
        "create-react-component",
        "setup-docker-container",
        "database-query-optimization",
        "git-commit-best-practices",
        "api-documentation-openapi"
      ]
    }
    ```

    **Skills Shown**: 14 skills (9 tech-specific + 5 universal)

    **Time Saved**: 1.5 minutes per skill search
  </Tab>

  <Tab title="Next.js Full-Stack App">
    ```json theme={null}
    {
      "repository": "nextjs-blog",
      "detected_technologies": [
        // Frontend
        "javascript", "typescript", "react", "nextjs",
        // Styling
        "tailwindcss", "styled-components",
        // Database
        "postgresql", "prisma",
        // Tools
        "git", "npm", "vercel"
      ],
      "matched_skills": [
        "create-react-component",
        "create-rest-api-client",
        "database-query-optimization",
        "setup-docker-container",
        "git-commit-best-practices",
        "api-documentation-openapi"
      ]
    }
    ```

    **Skills Shown**: 6 skills (3 tech-specific + 3 universal)

    **Filtered Out**: Laravel, Django, Vue.js, Angular skills
  </Tab>

  <Tab title="Python FastAPI Microservice">
    ```json theme={null}
    {
      "repository": "api-service",
      "detected_technologies": [
        // Backend
        "python", "fastapi", "pydantic",
        // Database
        "postgresql", "redis",
        // DevOps
        "docker", "kubernetes",
        // Tools
        "git", "pip"
      ],
      "matched_skills": [
        "database-query-optimization",
        "setup-docker-container",
        "git-commit-best-practices",
        "api-documentation-openapi",
        "create-rest-api-client"
      ]
    }
    ```

    **Skills Shown**: 5 skills (all universal—no Python-specific public skills yet)

    **Custom Skills**: Team can create Python-specific custom skills
  </Tab>
</Tabs>

***

## Viewing Your Tech Stack

### Via Dashboard

1. Navigate to **Repositories** at [app.ulpi.io/repositories](https://app.ulpi.io/repositories)
2. Click on your repository
3. View **Technologies** section
4. See all detected technologies with icons

### Via AI Assistant (MCP)

Ask your AI:

```
"What technologies does ULPI detect for this repository?"
```

Your AI will use MCP tools to show:

* All detected technologies
* Which skills are available
* Any missing technologies you should add

### Via API

```bash theme={null}
curl -H "Authorization: Bearer ulpi_live_..." \
     https://api.ulpi.io/v1/repositories/123/technologies
```

**Response**:

```json theme={null}
{
  "data": {
    "repository_id": 123,
    "technologies": [
      {
        "slug": "php",
        "name": "PHP",
        "icon_class": "devicon-php-plain",
        "detected_via": "composer.json"
      },
      {
        "slug": "laravel",
        "name": "Laravel",
        "icon_class": "devicon-laravel-plain",
        "detected_via": "composer.json, artisan file"
      },
      {
        "slug": "mysql",
        "name": "MySQL",
        "icon_class": "devicon-mysql-plain",
        "detected_via": ".env file, database/ directory"
      }
    ]
  }
}
```

***

## Technology Aliases

Some technologies have multiple names. ULPI handles aliases automatically.

**Examples**:

* **Node.js**: `nodejs`, `node`, `node-js` (all work)
* **PostgreSQL**: `postgresql`, `postgres`, `pg` (all work)
* **MongoDB**: `mongodb`, `mongo` (both work)
* **Kubernetes**: `kubernetes`, `k8s` (both work)
* **TypeScript**: `typescript`, `ts` (both work)

When filtering skills, ULPI checks against all aliases, so skills work correctly regardless of naming variation.

***

## Updating Tech Stack

Your tech stack is automatically updated:

**Automatic Updates**:

* ✅ **Push to repository** (via webhooks)
* ✅ **Manual refresh** in dashboard
* ✅ **Re-connection** of repository

**Update Frequency**:

* **Real-time**: On webhook events (push, PR merge)
* **Hourly**: Automatic background sync
* **Manual**: Click "Refresh" button in dashboard

**Cache Invalidation**:

* Tech stack changes invalidate skill cache
* MCP server refreshes on next request
* Or restart IDE to force immediate refresh

***

## Performance

Tech stack detection is optimized for speed:

**Detection Time**:

* **Small repos** (\< 100 files): 1-2 seconds
* **Medium repos** (100-1,000 files): 3-10 seconds
* **Large repos** (> 1,000 files): 10-30 seconds

**Caching**:

* Detected tech stack cached for 1 hour
* Skills filtered based on cached tech stack
* Full re-detection only on manual refresh or webhooks

**Optimization**:

* Only scans package manager files and root config
* Doesn't read entire codebase
* Uses file name patterns for fast detection
* Parallel analysis of multiple detection methods

***

## Troubleshooting

<AccordionGroup>
  <Accordion title="Technology not detected" icon="magnifying-glass">
    **Possible Causes**:

    1. Technology not in package manager file
    2. Files in subdirectory ULPI didn't scan
    3. Technology too new or not in ULPI database (288+ supported)

    **Solutions**:

    1. **Add manually** in repository settings → Technologies → Add Technology
    2. **Move package file to root** (e.g., `package.json`, `composer.json`)
    3. **Contact support** to request new technology addition
  </Accordion>

  <Accordion title="Wrong technologies detected" icon="triangle-exclamation">
    **Possible Causes**:

    1. Development dependencies included (e.g., Jest, Prettier in production stack)
    2. Deprecated packages still in `package.json`
    3. Multi-project repository (monorepo with multiple tech stacks)

    **Solutions**:

    1. **Remove unused dependencies** from package files
    2. **Clean up old packages** (`npm prune`, `composer update`)
    3. **Manually remove incorrect technologies** in repository settings
    4. **For monorepos**, consider separate ULPI repositories for each project
  </Accordion>

  <Accordion title="Skills not updating after tech stack change" icon="clock-rotate-left">
    **Cause**: MCP server cache (1 hour TTL)

    **Solutions**:

    1. **Restart IDE** to clear cache immediately
    2. **Wait 1 hour** for automatic cache expiration
    3. **Check "Updated At" timestamp** in repository settings to verify detection ran
  </Accordion>

  <Accordion title="Too many irrelevant skills" icon="list">
    **Possible Causes**:

    1. Too many technologies detected (e.g., dev dependencies)
    2. Development dependencies treated as production technologies
    3. Universal skills feel overwhelming (but they're supposed to show)

    **Solutions**:

    1. **Review and remove unused technologies** in repository settings
    2. **Focus `package.json` on production dependencies** (move dev deps to `devDependencies`)
    3. **Ask AI to filter**: "Show only Laravel-specific skills"
    4. **Create custom skills** with narrow tech filters
  </Accordion>
</AccordionGroup>

***

## Custom Technology Support

Need a technology ULPI doesn't support yet?

<Steps>
  <Step title="Check if Already Supported">
    Search 288+ technologies in repository settings → Add Technology
  </Step>

  <Step title="Submit Request">
    Email [support@ulpi.io](mailto:support@ulpi.io) with:

    * Technology name and website
    * Package manager identifier (npm package, composer package, PyPI package, etc.)
    * Why your team needs it
    * How many projects would benefit
  </Step>

  <Step title="Review">
    We review requests weekly
  </Step>

  <Step title="Addition">
    Popular requests added in 1-2 weeks
  </Step>

  <Step title="Notification">
    You'll be notified when technology is added
  </Step>
</Steps>

**Custom Internal Tools**:
For proprietary internal tools or frameworks:

1. Create custom skill with your tool's name
2. Manually add technology to repositories
3. Skills will match your custom tech stack

***

## Next Steps

<CardGroup cols={3}>
  <Card title="Create Custom Skills" icon="sparkles" href="/skills/custom-skills">
    Build skills filtered for your tech stack
  </Card>

  <Card title="How Skills Work" icon="lightbulb" href="/skills/how-skills-work">
    Technical deep dive into skill execution
  </Card>

  <Card title="MCP Setup" icon="plug" href="/skills/mcp-setup">
    Configure Skills in 40+ AI tools
  </Card>

  <Card title="Getting Started" icon="play" href="/skills/getting-started">
    Set up Skills from scratch in 10 minutes
  </Card>

  <Card title="Browse Skills" icon="list" href="/skills">
    View all 10 public skills
  </Card>

  <Card title="FAQ" icon="circle-question" href="/faq">
    Common questions
  </Card>
</CardGroup>

***

**Questions about tech stack matching?** Contact [support@ulpi.io](mailto:support@ulpi.io) or [join our Discord](https://discord.gg/ulpi).