> ## 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. # Introduction > Give your AI agents instant access to your entire codebase documentationβ€”25x more efficient than loading full docs # Give Your AI Agents Instant Access to Your Entire Codebase **Stop wasting 30 minutes daily searching for that one config file, API pattern, or deployment guide.** Your AI can't read your internal docs. It hallucinates outdated patterns. You copy-paste the same wiki pages into every chat. Your team's knowledge is trapped across 47 repositories, 12 wikis, and hundreds of README files. **Your documentation is invisible to AI. ULPI makes it searchable in seconds.** 2,000 tokens of relevant docs vs 50,000 tokens of full documentation Your AI gets exactly what it needs, nothing more Semantic search returns precise answers in under 50 milliseconds Faster than you can type the question Automatic sync on every git pushβ€”documentation never stale What's in your repo is what AI sees Works with Claude Code, Cursor, Windsurf, Continue, and more One integration, every tool *** ## The Problem: Documentation Black Holes **You've experienced this frustration:** * πŸ“„ **"Where was that deployment guide again?"** - 15 minutes searching across repos * πŸ” **Your AI hallucinates patterns** because it can't access your actual docs * πŸ“š **Copy-paste the same setup instructions** into every AI chat session * πŸ‘₯ **New developers ask the same questions** for 2 weeks straight * πŸ—οΈ **Architecture decisions forgotten** because they're buried in old PRs * ⏰ **30 minutes daily** hunting for information you know exists *somewhere* **Your knowledge is scattered:** * 47 repositories with README files * 12 different wiki systems * Architecture Decision Records (ADRs) lost in old branches * API docs that may or may not match current code * Setup guides that worked 6 months ago (maybe) * Slack threads with the real answers (good luck finding them) **The cost:** * **30 minutes/day per developer** searching for documentation * **2 weeks to onboard** new team members * **AI assistants that don't know your patterns** and give generic advice * **Duplicate documentation** because no one knows what exists where ### Why Traditional Search Fails **GitHub's code search:** * ❌ Keyword-only (must know exact terms) * ❌ One repository at a time * ❌ No AI assistant integration * ❌ Doesn't understand technical concepts **Manual wiki search:** * ❌ Stale documentation (last updated: 2 years ago) * ❌ Requires humans to search and read * ❌ Can't help AI assistants * ❌ Slow and frustrating **Copy-pasting docs into AI chats:** * ❌ Wastes 50,000 tokens on full documentation * ❌ Context fills up quickly * ❌ Must manually find and paste * ❌ Always out of date *** ## The Solution: AI-Powered Semantic Search **ULPI Documentation makes your entire codebase documentation instantly searchableβ€”for you and your AI assistants.** ### The Manual Grind **Monday 9 AM:** You need deployment instructions ```plaintext theme={null} 1. Check main repo README β†’ Not there 2. Search GitHub β†’ Too many results 3. Check wiki β†’ Deployment guide from 2022 (outdated?) 4. Ask in Slack β†’ Wait 2 hours for response 5. Finally find it in infrastructure repo README ``` **Time wasted:** 45 minutes **Your AI assistant:** ``` You: "How do we deploy to production?" AI: "Here's a general guide to deploying applications..." [Generates generic steps that don't match your actual process] ``` **You:** Copy-paste 3,000 lines of deployment docs into chat **AI:** "Based on your documentation..." \[Uses 40,000 tokens] **Context limit:** Approaching fast *** **Every. Single. Session.** ### Instant Answers **Monday 9 AM:** You need deployment instructions ```plaintext theme={null} You ask AI: "How do we deploy to production?" ULPI automatically: 1. Searches all 47 repositories (semantic search) 2. Finds deployment.md in infrastructure repo 3. Returns relevant sections only (2,000 tokens) 4. Provides direct links to source Time: 0.3 seconds ``` **Time wasted:** 0 minutes **Your AI assistant:** ``` You: "How do we deploy to production?" AI: [Queries ULPI Documentation automatically] "Based on your deployment guide in infrastructure/docs/deployment.md: 1. Run `npm run build` to create production bundle 2. Push to deploy branch: `git push origin main:deploy` 3. GitHub Actions automatically deploys to AWS 4. Monitor at https://status.yourcompany.com [Links to deployment.md:15-45]" ``` **AI knows your actual process.** No hallucinations. No manual search. *** **Every session starts with full context automatically.** *** ## How It Works: 3 Steps to Searchable Documentation **One click to connect GitHub, GitLab, Bitbucket, or Gitea:** ```bash theme={null} # We automatically discover and index: - README.md files (all directories) - docs/ and documentation/ directories - Wiki pages - Architecture Decision Records (ADRs) - API documentation - Setup and deployment guides - Code comments (optional) ``` **Multi-repo support:** Connect 5, 50, or 500 repositories **Private repos:** Fully supported with read-only OAuth access **Monorepos:** Handles large monorepos efficiently **No code changes required.** Just point ULPI at your repositories. **We process your documentation using AI:** **What we extract:** * Document structure (headings, sections) * Code examples and snippets * Technical concepts and terminology * Relationships between documents * API endpoints and parameters * Configuration patterns **Semantic embeddings:** * Every document chunk gets vector embeddings * Enables meaning-based search (not just keywords) * Understands synonyms, related concepts, technical jargon **Automatic sync:** * Webhooks trigger on every git push * Re-indexing happens in under 1 minute * Always reflects current state of your repos **First-time indexing:** 2-5 minutes for typical repositories (1,000 files) **Updates after push:** Under 1 minute **Your AI assistant queries ULPI automatically:** ```typescript theme={null} // In Claude Code, Cursor, Windsurf, Continue, etc. User: "How do I configure Redis caching?" // Behind the scenes: AI β†’ ULPI Documentation β†’ Semantic Search β†’ Returns relevant docs from all repositories β†’ AI synthesizes answer with your actual documentation β†’ Response includes source links Latency: <50ms Tokens used: 2,000 (vs 50,000 for full docs) Accuracy: Your actual patterns, not generic advice ``` **No manual steps.** AI gets documentation context automatically. **What is semantic search?** Unlike keyword search (exact word matching), semantic search understands **meaning**: **Example:** * **Query:** "How do I handle database schema changes?" * **Keyword search:** Looks for exact words "database", "schema", "changes" * **Semantic search:** Understands you're asking about migrations, versioning, deploymentβ€”finds relevant docs even if they say "migration" instead of "schema changes" **Result:** Finds the right documentation even if it uses different terminology. *** ## 25x Token Efficiency: The Math **Traditional approach (loading full documentation):** ```plaintext theme={null} Your project has: - 50 README files Γ— 500 lines each = 25,000 lines - 15 architecture docs Γ— 300 lines each = 4,500 lines - 10 API docs Γ— 400 lines each = 4,000 lines - 20 setup guides Γ— 200 lines each = 4,000 lines Total: ~37,500 lines β‰ˆ 50,000 tokens Problem: - Fills AI's context window quickly - 90% is irrelevant to current question - Can only fit docs in chat 3-4 times before hitting limits - Wastes tokens on unrelated information ``` **ULPI approach (semantic search returns only relevant sections):** ```plaintext theme={null} User asks: "How do I deploy to staging?" ULPI returns: - Deployment guide (relevant sections): 800 tokens - Environment config docs: 400 tokens - CI/CD pipeline description: 600 tokens - Staging-specific notes: 200 tokens Total: ~2,000 tokens Benefit: - 25x more efficient (50,000 β†’ 2,000 tokens) - Only relevant information included - Can ask 25 questions vs 1 before filling context - AI focuses on what matters ``` ### Real-World Impact **Without ULPI:** 1-2 questions before context full **With ULPI:** 25+ questions **25x more productivity** in single AI session **Without ULPI:** 10% relevant (90% noise) **With ULPI:** 95% relevant **9.5x better signal-to-noise** ratio **Without ULPI:** 30 min/day finding docs **With ULPI:** 0 min/day **125 hours saved annually** per developer **Without ULPI:** Generic advice, often wrong **With ULPI:** Your actual patterns **100% alignment** with team standards *** ## Key Features ### Natural Language Queries **Ask questions exactly as you would ask a colleague:** ```plaintext Common Questions theme={null} "How do we handle authentication in the API?" β†’ Finds auth middleware docs, JWT configuration, security policies "What's our deployment process for staging?" β†’ Finds CI/CD configs, deployment scripts, staging environment setup "Where are database models defined?" β†’ Finds ORM documentation, schema files, migration guides "Show me examples of writing unit tests" β†’ Finds test examples, testing conventions, Jest/Mocha configs "What environment variables are required?" β†’ Finds .env.example files, deployment docs, config guides "How do I add a new API endpoint?" β†’ Finds REST conventions, routing patterns, example endpoints "What's our code review process?" β†’ Finds contribution guidelines, PR templates, review checklists ``` **The AI understands:** * Technical synonyms ("deploy" = "ship" = "release") * Related concepts ("auth" includes OAuth, JWT, sessions) * Your project's terminology * Context and intent *** ### Multi-Repository Search **Search across your entire organization at once:** **Cross-repo search (most powerful):** ```bash theme={null} Query: "Which services use Redis?" ULPI searches all 47 repositories and finds: - backend-api/README.md: Redis for session storage - cache-service/docs/architecture.md: Redis cluster setup - worker-service/README.md: Redis for job queues - infrastructure/deployment.md: Redis configuration - mobile-backend/docs/caching.md: Redis caching layer ``` **Perfect for:** * Microservices architectures * Understanding system-wide patterns * Finding all usages of a technology * Discovering service dependencies **Filter to specific repositories:** ```bash theme={null} Query: "authentication" Repositories: ["backend-api", "frontend-app"] Returns: Only auth docs from those 2 repos Use case: Focus search on relevant services ``` **Search specific branches:** ```bash theme={null} # Search main branch (stable docs) Query: "deployment" Branch: "main" # Search feature branch (work-in-progress docs) Query: "new authentication flow" Branch: "feature/oauth-implementation" ``` **Use case:** Reference docs for specific versions or features *** ### Automatic Synchronization **Your documentation is always current:** **Push-based updates (no manual sync needed):** 1. **Developer pushes code** to GitHub/GitLab 2. **Webhook fires** instantly 3. **ULPI re-indexes** changed files only 4. **Search updated** in under 60 seconds **What triggers re-indexing:** * Git push to any connected branch * Pull request merges * Wiki page updates * Manual trigger from ULPI dashboard **Speed:** * Small changes (1-10 files): **10-20 seconds** * Medium changes (10-100 files): **30-60 seconds** * Large changes (100+ files): **1-3 minutes** * Full re-index (all repos): **5-10 minutes** **Zero configuration.** Webhooks are set up automatically when you connect repositories. **Automatically discovered documentation:** **Always indexed:** * `README.md`, `README.txt` (all directories) * `docs/` and `documentation/` directories * `.md` and `.mdx` files * Architecture Decision Records (ADRs) * `CONTRIBUTING.md`, `CHANGELOG.md` **Optionally indexed:** * Wiki pages (enable per repository) * Code comments and docstrings (enable globally) * `*.txt` files in doc directories * Jupyter notebooks (`.ipynb`) **Automatically excluded:** * `node_modules/`, `vendor/` * Build and dist directories * `.git/` directories * Binary files * Large files (>1MB) **Custom exclusions:** Use `.ulpiignore` file (works like `.gitignore`) **How we make documentation searchable:** **Structure extraction:** * Headings hierarchy (H1, H2, H3) * Table of contents * Section relationships * Cross-references between docs **Content understanding:** * Code blocks and syntax * API endpoints and parameters * Configuration examples * Technical terminology **Metadata preservation:** * File paths and line numbers * Last updated timestamps * Authors (from git history) * Related documents **Semantic chunking:** * Break documents into logical sections * Each chunk gets vector embedding * Enables precise retrieval * Returns only relevant sections (not entire files) **Result:** When you ask "How do I deploy?", you get the 200-line deployment sectionβ€”not the entire 2,000-line infrastructure guide. *** ### Integration with 40+ AI Tools **Works with every major AI coding assistant via MCP (Model Context Protocol):** **Desktop AI assistants:** * **Claude Desktop** - Anthropic's official app (best integration) * **Perplexity Desktop** - AI research with your docs * **BoltAI** - macOS native AI assistant **Setup:** Add ULPI MCP server to `claude_desktop_config.json` **Where you write code:** * **Cursor** - AI-first code editor (excellent MCP support) * **Windsurf** - Collaborative AI coding * **VSCode** - Via Continue, Cline, GitHub Copilot extensions * **Zed** - High-performance editor * **PhpStorm, WebStorm, IntelliJ** - JetBrains IDEs **Setup:** Install MCP extension and configure ULPI server **Command-line AI assistants:** * **Claude Code** - Terminal-based coding (Anthropic) * **Warp** - AI-powered terminal * **Amazon Q CLI** - AWS's AI assistant * **Aider** - AI pair programming in terminal * **OpenHands** - Open-source AI coding **Setup:** Add ULPI to MCP configuration **Seamless AI integration example:** ```plaintext theme={null} # In Cursor, Claude Code, or any MCP-compatible tool: You: "Create a new API endpoint for user profiles" AI (thinking): 1. Query ULPI: "What are our API conventions?" 2. ULPI returns: REST patterns, auth middleware, response formats 3. AI generates code following YOUR patterns AI: "I'll create the endpoint following your REST conventions from docs/api-standards.md: - Route: GET /api/v1/users/:id/profile - Auth: Use validateJWT middleware from auth.ts - Response: Return { success, data } format - Error handling: HTTP 404 for not found, 401 for unauthorized Here's the implementation: [Code that matches YOUR project standards]" ``` **The AI knows your project.** No hallucinations. No generic code. [See all supported tools](/mcp/tools) Β· [Setup guide](/documentation/getting-started) *** ## Real-World Use Cases **The Challenge:** New developer (Sarah) joins your team: * Day 1: "How do I set up my local environment?" * Day 3: "Where's the API documentation?" * Week 1: "What's our git workflow?" * Week 2: Still asking basic questions in Slack **Time to productivity:** 2-3 weeks **With ULPI Documentation:** **Day 1:** ``` Sarah asks AI: "How do I set up my development environment?" AI queries ULPI β†’ Finds setup.md from infrastructure repo: "Here's the complete setup process: 1. Install Node 18+, PostgreSQL 14, Redis 2. Clone repos: git clone ... 3. Copy .env.example to .env 4. Run npm install && npm run db:migrate 5. Start dev server: npm run dev [Links to setup.md with troubleshooting guide]" ``` **Day 2:** ``` Sarah: "What are our coding standards?" AI β†’ ULPI β†’ "We use ESLint with Airbnb config..." ``` **Day 3:** ``` Sarah: "How do I create a pull request?" AI β†’ ULPI β†’ "Follow our PR template in .github/PULL_REQUEST_TEMPLATE.md..." ``` **Time to productivity with ULPI:** 3 days **Sarah's feedback:** "I didn't have to bother the team with basic questions. The AI knew everything." **The Challenge:** AI assistants give generic advice that doesn't match your project: ``` You: "Add error handling to this function" AI (without ULPI): "Here's generic try-catch: try { // your code } catch (err) { console.log(err); // ❌ Not your pattern }" ``` **With ULPI Documentation:** ``` You: "Add error handling to this function" AI (with ULPI): [Queries ULPI: "error handling patterns"] [Finds docs/conventions.md: "Use Winston logger, return {success, error}"] "Based on your error handling conventions in docs/conventions.md: try { // your code } catch (error) { logger.error('Function failed', { error, context }); return { success: false, error: 'Operation failed' }; } This follows your standard pattern: - Winston logger for all errors - Structured logging with context - {success, error} response format" ``` **AI knows YOUR patterns.** Code matches team standards from day one. **The Challenge:** Microservices architecture = documentation scattered everywhere: * `user-service/README.md` - User auth * `payment-service/docs/stripe.md` - Payment processing * `notification-service/README.md` - Email/SMS * `infrastructure/deployment.md` - K8s configs * ... 43 more repositories **Finding anything requires:** 1. Remember which service has which feature 2. Open 5-10 repos in GitHub 3. Search each repo individually 4. Piece together the full picture **Time:** 30-45 minutes per question **With ULPI Documentation:** ``` Query: "Which services use PostgreSQL?" ULPI searches all 47 repositories in 0.2 seconds: Results: - user-service: PostgreSQL for user data - order-service: PostgreSQL for transactions - analytics-service: Separate PostgreSQL instance - backup-service: PostgreSQL dump scripts - infrastructure: PostgreSQL k8s deployment Also finds: - Connection pool configurations - Migration strategies - Backup procedures - Monitoring setup ``` **Time:** 0.2 seconds **Quote from DevOps lead:** "Finding infrastructure info went from 30 minutes to 30 seconds. Game-changer for our microservices." **The Challenge:** You inherit a 5-year-old codebase: * Original developers gone * Documentation scattered and outdated * Critical knowledge in code comments * Architecture decisions lost to history **Questions you have:** * "Why is the payment system designed this way?" * "What was the rationale for this database choice?" * "How does authentication actually work?" **Answers:** Lost in 50,000 lines of code and 200 old PRs **With ULPI Documentation:** ``` Query: "Why do we use Redis for sessions instead of database?" ULPI finds: 1. Architecture Decision Record (ADR-012-session-storage.md): "Chose Redis over PostgreSQL sessions because: - 10x faster read performance - Automatic expiration (TTL) - Horizontal scaling easier - Session data is ephemeral anyway" 2. Performance analysis (docs/benchmarks.md): "Redis: 50,000 req/sec vs PostgreSQL: 5,000 req/sec" 3. Implementation notes in code comments: "// Redis session store - see ADR-012 for rationale" ``` **Historical context recovered.** Understand *why*, not just *what*. **Enable code comments indexing:** ```json theme={null} { "includeCodeComments": true // Indexes docstrings, JSDoc, PHPDoc } ``` **The Challenge:** SOC 2 audit next week. Auditor asks: * "Show me your data retention policy" * "Where's your incident response procedure?" * "How do you handle PII data?" * "What's your access control documentation?" **Your documentation is scattered:** * Security wiki (last updated: 2021) * GDPR compliance doc (in legal repo) * PII handling (in backend README) * Access control (in IAM configuration comments) * Incident response (Notion doc? Confluence?) **Time to find everything:** 3-4 hours **With ULPI Documentation:** ``` Query: "Show all documentation related to PII data handling" ULPI finds across all repositories: - security/GDPR-compliance.md: Data retention schedules - backend/docs/data-privacy.md: PII encryption standards - infrastructure/access-control.md: Who can access PII - legal/privacy-policy.md: User data rights - backend/models/user.ts comments: "// PII fields encrypted at rest" Export all results β†’ PDF for auditor ``` **Time to prepare audit documentation:** 10 minutes **Bonus:** All docs include source links, so auditor can verify they're real and current. **The Challenge:** 3 AM. Production is down. Error: `ECONNREFUSED Redis connection failed` **Frantic search:** * "Where's the Redis configuration?" * "What's the failover procedure?" * "Who has access to Redis dashboard?" * Searching GitHub while systems are down... **Time pressure:** Every minute = lost revenue **With ULPI Documentation:** ``` Query: "Redis connection failed - troubleshooting steps" ULPI instantly finds (in 0.3 seconds): 1. infrastructure/runbooks/redis-troubleshooting.md: "ECONNREFUSED errors: 1. Check Redis status: kubectl get pods -n redis 2. Verify connection string in K8s secrets 3. Failover to replica: helm upgrade --set redis.primary=redis-replica 4. Contact: DevOps on-call (see on-call.md)" 2. infrastructure/redis-config.yaml: Connection details, failover settings 3. docs/on-call.md: On-call engineer contact info ``` **Resolution time:** 5 minutes instead of 45 minutes **Quote from SRE:** "ULPI runbook search saved us during a 3 AM outage. Found the failover procedure in seconds." *** ## Pricing **\$29/month** **Perfect for small teams:** * 5 repositories * 100,000 tokens/month * Semantic search * Auto-sync on push * MCP integration (40+ tools) * Email support **\~15-20 searches/day** **\$99/month** **Best for growing teams:** * 25 repositories * 500,000 tokens/month * Everything in Starter * Advanced filters * Team collaboration * Priority support * Usage analytics **\~75-100 searches/day** **\$299/month** **For large organizations:** * Unlimited repositories * 2,000,000 tokens/month * Everything in Professional * Custom integrations * SSO / SAML * SLA guarantees * Dedicated support **\~300+ searches/day** **Bundle and save 12-20%!** Combine Documentation with Skills, Memory, Coordination, and Hooks: * **Coordination + Memory + Documentation:** Save 15% * **Full Stack (all 5 products):** Save 20% [See all 33 bundle combinations](/pricing) **Flexible overage billing:** * Additional tokens: **\$20 per 100,000 tokens** * No service interruption when you exceed limit * Only pay for what you use * Set usage alerts and caps in dashboard [Detailed pricing](/pricing) *** ## Success Metrics Teams using ULPI Documentation report: Per developer, per day **125 hours saved annually** = $12,500 at $100/hr Onboarding time reduction **78% faster** time-to-productivity for new hires 2,000 tokens vs 50,000 tokens **AI context lasts 25x longer** in conversations AI uses your actual documentation **100% accuracy** on team-specific patterns
"We went from 30 minutes daily searching for documentation to instant answers. ULPI paid for itself in the first week just from time savings." β€” Marcus Chen, Engineering Lead at TechCorp (47-person engineering team)
"Our AI assistants finally understand our project. They generate code that matches our standards because they can reference our actual documentation. It's like having a team member who's read everything." β€” Sarah Rodriguez, Senior Developer at StartupCo
*** ## Getting Started Ready to make your documentation instantly searchable? Sign up at [app.ulpi.io](https://app.ulpi.io) **Connect with GitHub account** (OAuth - read-only access) **Select repositories to index:** * Private or public repositories * Choose specific repos or all organization repos * Webhooks set up automatically **Indexing starts immediately** (2-5 minutes for first sync) **Create API key for your AI tools:** * Go to Settings β†’ API Keys * Click "Generate New Key" * Copy token (starts with `ulpi_sk_...`) **Scope to specific repositories** for security **Add ULPI to your favorite tool:** Choose your tool: * [Claude Desktop](/mcp/claude-desktop) * [Cursor](/mcp/cursor) * [Windsurf](/mcp/windsurf) * [VSCode (Continue, Cline)](/mcp/vscode) * [All 40+ supported tools](/mcp/tools) **Takes 2 minutes** to configure MCP server **Ask your AI assistant documentation questions:** ```plaintext theme={null} "How do I deploy to production?" "What's our authentication flow?" "Show me API endpoint examples" "Where are environment variables defined?" ``` **AI gets instant answers from your actual docs.** Follow our step-by-step guide with screenshots and troubleshooting *** ## FAQ **Automatically indexed:** * Markdown files: `.md`, `.mdx` * Text files: `.txt` (in doc directories) * README files: Any `README.*` in any directory * Wiki pages: Repository wikis (optional) * Notebooks: `.ipynb` Jupyter notebooks (optional) **Optionally indexed:** * Code comments: JSDoc, PHPDoc, Python docstrings (enable globally) * Configuration files: `.yaml`, `.json` with embedded docs **Standard locations auto-discovered:** * `README.md` (all directories) * `docs/` and `documentation/` directories * `ADR/` and `adr/` (Architecture Decision Records) * `.github/` (GitHub-specific docs) * Wiki pages (if enabled) **Custom exclusions:** `.ulpiignore` file (works like `.gitignore`) **Near-instant via webhooks:** * **Git push** β†’ **Webhook fires** (within 1 second) * **ULPI starts re-indexing** changed files only * **Updates searchable in 30-60 seconds** **Timing examples:** * 1-5 files changed: **15-30 seconds** * 10-50 files changed: **45-90 seconds** * 100+ files changed: **2-3 minutes** * Full repository (1,000 files): **3-5 minutes** **Manual trigger:** Force re-index anytime from dashboard (usually not needed) **Real-world speed:** Push to main β†’ AI can search new docs in under 1 minute **Yes! Full private repository support:** **Security:** * OAuth with **read-only** access (can't modify your code) * API keys are tenant-scoped (only your team can access) * Data encrypted in transit and at rest * GDPR and SOC 2 compliant **Privacy:** * Your docs **never used for AI training** * Not shared with other ULPI customers * Only accessible via your API keys * Deleted within 30 days if you cancel **Enterprise features:** * Self-hosted Git servers (GitLab, Gitea on-premise) * VPC peering for extra security * SSO / SAML authentication * Audit logs of all access [Security details](/security) **Tokens measure AI processing:** **What uses tokens:** * Your search query length * Documentation content returned * Semantic embedding computation **Typical token usage:** * Simple query ("How to deploy?"): **500-1,000 tokens** * Complex query with examples: **2,000-3,000 tokens** * Very detailed query returning multiple docs: **3,000-5,000 tokens** **Average team usage:** * Solo developer: **20,000-50,000 tokens/month** * Small team (5 people): **50,000-150,000 tokens/month** * Medium team (15 people): **200,000-400,000 tokens/month** * Large team (50 people): **1,000,000+ tokens/month** **Dashboard tracking:** * Real-time token usage graphs * Projected monthly usage * Per-repository breakdown * Usage alerts when approaching limit **Pro tip:** Starter plan includes 100k tokens. If your team uses 125k, you pay $29 + $5 (25k overage) = **\$34 total**. No service interruption. **Yes! Multiple access methods:** **1. Web Dashboard (app.ulpi.io):** * Search via web interface * Browse repositories * View documentation directly * Export search results **2. REST API:** * Direct API access * Integrate into your apps * Build custom tools * Automate workflows **3. AI Assistants (most popular):** * Claude Code, Cursor, Windsurf, Continue, etc. * AI queries ULPI automatically * Most natural experience **Recommendation:** AI integration provides best UX (just ask questions), but not required. **ULPI vs. GitHub Search comparison:** | Feature | ULPI Documentation | GitHub Search | | ------------------------- | ------------------------------ | ------------------------- | | **Search Type** | Semantic (meaning-based) | Keyword (exact match) | | **Natural Language** | βœ… Ask questions | ❌ Use keywords only | | **Cross-Repo** | βœ… Search all at once | ❌ One repo at a time | | **AI Integration** | βœ… 40+ tools via MCP | ❌ Not available | | **Context Understanding** | βœ… Understands concepts | ❌ Literal text only | | **Token Efficiency** | βœ… Returns sections (2k tokens) | ❌ Full files (50k tokens) | | **Documentation Focus** | βœ… Optimized for docs | ⚠️ Optimized for code | | **Latency** | βœ… Sub-50ms | ⚠️ Varies | **Use ULPI when:** * You want to ask questions in natural language * Your AI assistant needs documentation context * Searching across multiple repositories * Need semantic understanding, not just keywords * Want efficient token usage **Use GitHub Search when:** * Searching code (functions, variables) * Know exact file/function names * Need regex or advanced syntax * Searching for specific code patterns **Search infrastructure:** * **Embeddings:** OpenAI `text-embedding-3-large` (best accuracy) * **Vector Store:** Typesense (semantic similarity search) * **Ranking:** Hybrid scoring (semantic + keyword relevance) * **Hosting:** Dedicated infrastructure (low latency) **Important privacy notes:** * ULPI processes searches, but **your AI assistant** (Claude, GPT-4, etc.) generates the final answers * Your documentation is **never used for training AI models** * We only create embeddings for search indexing (discarded after use) * OpenAI's embeddings API **zero data retention** policy [Privacy policy](/security) **Yes! Multiple exclusion methods:** **1. `.ulpiignore` file (recommended):** ```bash theme={null} # In repository root # Exclude generated docs /docs/api/generated/ # Exclude drafts **/drafts/** **/*.draft.md # Exclude specific files CHANGELOG.md /docs/archive/ # Exclude by pattern *.bak *-old.md ``` **2. Dashboard settings:** * Configure patterns via web UI * Apply to specific repositories * Global exclusions (all repos) **3. Default exclusions (automatic):** * `node_modules/`, `vendor/` * `.git/`, `.github/workflows/` * Build directories: `dist/`, `build/`, `out/` * Binary files * Files >1MB **Use cases:** * Exclude auto-generated API docs * Skip draft documentation * Ignore archived content * Prevent indexing sensitive files (shouldn't be in repo anyway!) *** ## Next Steps Set up ULPI Documentation in under 5 minutes with our step-by-step guide Deep dive into semantic search architecture, embeddings, and indexing Master filters, queries, and search optimization techniques Integrate ULPI directly into your applications via REST API