Tech Stack Matching

How ULPI detects your technologies and matches skills to your repository

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

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

---

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.

Reduce Noise

See only skills that apply to your tech stack. No PHP skills in Python repos, no React skills in Laravel-only projects.

Save Time

Find the right skill in 5 seconds instead of 2 minutes. AI doesn’t waste time reading irrelevant skills.

Prevent Errors

AI can’t accidentally use Laravel patterns in a Django project. Stack-specific skills enforce correct patterns.

Scale Gracefully

As you add more skills, filtering keeps your skill list manageable. 100 total skills → 10 relevant skills per repo.

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.

JavaScript/TypeScript

File: package.json

{
  "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

Step 2: Configuration File Detection

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

Laravel Detection

Marker Files:

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

Result: Confirms Laravel framework usage

React Detection

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

Docker Detection

Marker Files:

• Dockerfile
• docker-compose.yml
• .dockerignore

Result: Confirms Docker containerization

Database Detection

Marker Files:

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

Result: Confirms database usage (MySQL, PostgreSQL, etc.)

Step 3: Language Detection

ULPI counts file extensions to determine primary and secondary languages.

Example Analysis:

{
  ".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.

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

Step 5: Tool Detection

ULPI identifies DevOps and infrastructure tools used in your project.

Docker

Files:

• Dockerfile exists
• docker-compose.yml exists

Result: Docker detected

Git

Files:

• .git/ directory
• .gitignore file

Result: Git detected (always)

GitHub Actions

Files:

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

Result: GitHub Actions detected

GitLab CI

Files:

• .gitlab-ci.yml exists

Result: GitLab CI detected

Jenkins

Files:

• Jenkinsfile exists

Result: Jenkins detected

CircleCI

Files:

• .circleci/config.yml exists

Result: CircleCI detected

---

Supported Technologies (288+)

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

Programming Languages (15+)

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)

Backend Frameworks (45+)

PHP Frameworks (31 items)

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)

Node.js Frameworks (35+ items)

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)

Python Frameworks

• Django (full-stack)
• FastAPI (modern API)
• Flask (micro-framework)
• Pyramid (flexible)
• Tornado (async)

Other Backend Frameworks

• Spring Boot (Java)
• ASP.NET Core (C#)
• Ruby on Rails (Ruby)
• Phoenix (Elixir)
• Gin, Echo (Go)
• Actix, Rocket (Rust)

Frontend Frameworks (46+)

React Ecosystem (46 items)

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

Other Frontend Frameworks

• Vue.js, Nuxt.js
• Angular
• Svelte, SvelteKit
• Solid.js
• Ember.js
• Preact

Databases (25+)

Relational

• MySQL (most popular)
• PostgreSQL (advanced)
• MariaDB
• SQLite
• Oracle
• SQL Server

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:

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"]

Skill 1: Create Laravel API Endpoint

Filters: ["php", "laravel"]

Match: ✅ Yes

Reason: Both php and laravel are in repository technologies

---

Universal Skills

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

Universal Skills Examples:

Git Commit Best Practices

Version control applies to all projects—PHP, Python, JavaScript, etc.

API Documentation with OpenAPI

API documentation is language-agnostic. Works with Laravel, Django, Express, Spring Boot, etc.

Setup Docker Container

Containerization applies to all tech stacks. Docker works with any language/framework.

Database Query Optimization

SQL optimization concepts are universal across MySQL, PostgreSQL, MariaDB, etc.

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.

1. Navigate to Repository

   In ULPI dashboard, go to Repositories → Select your repository

2. View Tech Stack Section

   Scroll to Technologies section

3. Click Add Technology

   Click + Add Technology button

4. Search Technologies

   Search from 288+ supported technologies:

   • Start typing (e.g., “Vue”)
   • Select from dropdown
   • Multiple selections allowed
5. Save

   Click Save to update your tech stack

6. Refresh Skills

   Restart your IDE to clear MCP cache

   Skills will now be filtered with updated tech stack

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:

Full-Stack Laravel + React

{
  "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

---

Viewing Your Tech Stack

Via Dashboard

1. Navigate to Repositories at 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

curl -H "Authorization: Bearer ulpi_live_..." \
     https://api.ulpi.io/v1/repositories/123/technologies

Response:

{
  "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

Technology not detected

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

Wrong technologies detected

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

Skills not updating after tech stack change

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

Too many irrelevant skills

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

---

Custom Technology Support

Need a technology ULPI doesn’t support yet?

1. Check if Already Supported

   Search 288+ technologies in repository settings → Add Technology

2. Submit Request

   Email [e-mail] 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
3. Review

   We review requests weekly

4. Addition

   Popular requests added in 1-2 weeks

5. Notification

   You’ll be notified when technology is added

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

Create Custom Skills

Build skills filtered for your tech stack

How Skills Work

Technical deep dive into skill execution

MCP Setup

Configure Skills in 40+ AI tools

Getting Started

Set up Skills from scratch in 10 minutes

Browse Skills

View all 10 public skills

FAQ

Common questions

---

Questions about tech stack matching? Contact [e-mail] or join our Discord.