Included in Pro
Everything. Included.
Every feature below is included in Pyckle Pro at $20/mo. No add-ons, no upsells, no surprises. One price, one decision.
Custom PyckLM Tuning
Your codebase speaks its own language. Teach Pyckle to understand it.
Every codebase has unique conventions, naming patterns, and architectural decisions that generic embedding models struggle to capture. Custom PyckLM Tuning fine-tunes our embedding model specifically on your code, learning the semantic relationships between your functions, classes, and modules.
The tuning process analyzes your codebase structure, commit history, and documentation to build a model that understands what "the auth handler" or "that validation logic" means in your specific context. This can result in up to 2-3x better retrieval accuracy compared to out-of-the-box embeddings, depending on codebase size and complexity.
What you get
- Custom embedding model trained on your codebase
- Up to 2-3x improvement in semantic search accuracy
- Better understanding of domain-specific terminology
- Improved retrieval for internal naming conventions
- One free model refresh within 90 days of purchase
Ideal for: Teams with large codebases, proprietary frameworks, or specialized domains where generic models miss important context.
Codebase Refresh
Keep your index current when your code evolves.
Codebases change. New features get added, old modules get refactored, and entire architectures can shift over time. When your code diverges significantly from its indexed state, search quality degrades.
A Codebase Refresh re-indexes your entire project from scratch, capturing all structural changes, new files, renamed modules, and updated documentation. Unlike incremental updates, a full refresh ensures complete consistency.
What you get
- Complete re-indexing of your codebase
- Updated file maps and dependency graphs
- Fresh analysis of code structure and relationships
- Removal of stale references to deleted files
- Priority processing — runs automatically
Ideal for: Teams who've completed major refactors, added significant new features, or haven't refreshed in several months.
Multi-platform Export
One index, every AI coding tool.
Your team doesn't all use the same tools. Some prefer Cursor, others swear by GitHub Copilot, and a few have switched to Windsurf. Without Multi-platform Export, each tool operates in isolation.
This feature generates configuration files tailored for each major AI coding assistant. All exports draw from the same indexed codebase, ensuring consistency across your entire team.
Supported platforms
- Claude Code (CLAUDE.md)
- Cursor (.cursorrules, .cursorcontext)
- GitHub Copilot (custom instructions)
- Windsurf (workspace context)
- Continue.dev (context providers)
- Generic formats for other tools
Ideal for: Teams with diverse tooling preferences, or developers who switch between multiple AI assistants.
Dynamic Threshold Monitoring
Smarter retrieval that adapts to how you search.
Semantic search relies on similarity thresholds to decide what's relevant. The optimal threshold varies based on query type, codebase density, and even time of day.
Dynamic Threshold Monitoring continuously analyzes your query patterns and adjusts retrieval parameters in real-time. The system learns from implicit feedback and builds a profile of your search behavior.
What you get
- Automatic threshold adjustment based on query type
- Learning from your search patterns and behavior
- Better precision for specific queries
- Better recall for exploratory searches
- Monthly analytics reports on search quality
Ideal for: Power users who search frequently and want consistently relevant results without manual tuning.
Dynamic Codebase Monitoring
Your index stays fresh automatically.
Manual refreshes are a chore. You finish a feature, push to main, and three days later realize your Pyckle index is stale.
Dynamic Codebase Monitoring watches your repository for significant changes and triggers automatic re-indexing when needed. It integrates with GitHub, GitLab, and Bitbucket webhooks to detect pushes in real-time.
What you get
- Automatic re-indexing on significant code changes
- GitHub, GitLab, and Bitbucket integration
- Configurable sensitivity (commit count, file changes, etc.)
- Email notifications when index updates complete
- Change logs showing what was added/modified/removed
Ideal for: Active repositories with frequent commits, teams who forget to manually refresh, or CI/CD-driven workflows.
Query Pattern Training
The more you search, the smarter Pyckle gets.
Every search you run is a signal about what matters in your codebase. Query Pattern Training captures these signals and uses them to continuously improve your personalized model.
The system builds query-to-code mappings based on your actual usage. When you search "error handling" and spend time in src/utils/errors.ts, that association strengthens.
What you get
- Continuous learning from your search behavior
- Personalized ranking based on your usage patterns
- Query-to-code association mapping
- Improved results for frequently searched concepts
- Quarterly model evolution reports
- Ability to export learned patterns for team sharing
Ideal for: Long-term Pyckle users who want search quality that improves over time without manual intervention.
Native AST Parsing
For Java, Kotlin, and Swift — accurate indexing from genuine AST, not regex.
Regex-based parsing misses nested classes, lambda expressions, and annotation-heavy code. Tree-sitter provides genuine abstract syntax tree parsing — extracting classes, methods, and imports with 100% accuracy across complex mobile and JVM codebases.
Your Java, Kotlin, and Swift code now gets the same indexing quality as Python and TypeScript. Annotations, generics, inner classes, companion objects, and extension functions are all captured correctly.
What you get
- Tree-sitter AST parsing for .java, .kt, .swift files
- Accurate extraction of nested classes and inner types
- Annotation and decorator awareness
- Method signature extraction including generics
- Graceful fallback to regex if grammar not available
Ideal for: Android, iOS, and JVM teams who previously got poor search results from mobile codebases.
Cross-File Signature Visibility
See what you import, not just what you search.
When you search for a function, you need to understand its dependencies. Cross-file signature visibility automatically includes imported function and class signatures in your search results — sourced from the dependency graph at query time.
Your AI sees the full picture without extra queries: the function you found, plus the signatures of everything it calls. No manual graph_neighbors invocations needed.
What you get
- Imported signatures appended to each search result
- Cached lazily — no latency on first index build
- Up to 10 signatures per file surfaced automatically
- Works alongside graph_neighbors for full dep exploration
Ideal for: Navigating large codebases where a function's behavior depends on many imported utilities.
Memory Auto-Capture
Your session remembers what mattered. Automatically.
No more manually saving context. Every file you edit and every high-confidence search query is automatically weighted and stored in your session memory. Edited files receive a 0.8 importance score; top queries receive 0.5.
When you resume work tomorrow, Pyckle knows where you left off — files you were editing are boosted in search results, and your most-used queries return faster.
What you get
- Automatic memory creation from edited files (importance 0.8)
- Top-3 queries auto-saved with importance 0.5
- Memories tagged "auto" for easy filtering
- Session resumption with warm-file boosting
- Works alongside manual add_memory for explicit saves
Ideal for: Developers who work across multiple sessions and want continuity without manual context management.
GitHub & GitLab Issue Webhooks
Issues and PRs indexed as they happen — not hours later.
Connect your repo and every issue, PR, and comment is indexed in real-time via webhook. When an issue is closed, it's removed from the index automatically. When a PR is updated, the new diff replaces the old one.
fetch_incremental pulls only deltas — no re-indexing your entire history on every update. Search your backlog alongside your code.
What you get
- Real-time indexing of issues and PRs on open/edit/close
- HMAC signature verification on all webhook events
- fetch_incremental for delta-only updates (no full re-index)
- GitLab MR support alongside GitHub PRs
- Labels, state, and assignee metadata in search results
Ideal for: Teams who want to search "what issues relate to the auth module" without leaving their editor.
Diff Review CI
Pyckle reviews every PR automatically — using your codebase context, not just the diff.
Drop one GitHub Action into your workflow and every PR gets a context-aware review comment. The review includes blast-radius warnings from the dependency graph and severity scoring (🔴 HIGH / 🟡 MEDIUM / 🟢 LOW).
The review is non-blocking — errors exit 0 so your pipeline never stalls on a Pyckle outage. Severity is escalated automatically if security keywords appear in any finding.
What you get
- GitHub Action workflow — copy-paste setup in 2 minutes
- Severity scoring: 🔴 HIGH / 🟡 MEDIUM / 🟢 LOW
- Auto-escalation for security/auth/injection keywords
- Changed file list + finding count in every comment
- Non-blocking: never fails your pipeline
Ideal for: Engineering leads who want a second opinion on every PR without adding a slow, expensive review gate.
Coverage Runner
Coverage stats without leaving your context.
run_coverage() auto-detects your test framework — pytest, jest, or vitest — executes coverage, and returns per-file percentages as a structured result. Know what's tested before you change it.
The get_coverage MCP tool surfaces coverage gaps directly in your AI context, so you can target untested paths without switching to a separate terminal or CI dashboard.
What you get
- Auto-detection: pytest, jest, vitest, go test
- Per-file line coverage percentages
- Overall project coverage total
- Graceful error if framework not installed
- Configurable timeout (default 120s)
Ideal for: Before refactoring — run coverage, find the untested paths, and know what you're risking.
Notion OAuth
Index your team wiki alongside your code.
Full OAuth 2.0 flow — connect Notion with one click, and your databases and pages become searchable alongside your codebase. Multi-user support means every teammate can index their own workspace without sharing tokens.
Once connected, index_notion fetches your pages and stores them in the same ChromaDB collection as your code, making them retrievable via search_code.
What you get
- Standard OAuth 2.0 auth code flow (no PKCE required)
- /auth/notion and /auth/notion/callback routes
- Multi-user: each user connects their own workspace
- Notion pages searchable via the standard search_code tool
- Workspace name and bot ID returned on token exchange
Ideal for: Teams who maintain technical docs, runbooks, or architecture decisions in Notion and want to search them alongside their code.
Debounced Smart Reindex
Fast saves, smart indexing — your index stays fresh without burning CPU.
ReindexQueue coalesces rapid IDE saves into a single re-embed per file. A 500ms debounce window means your index stays fresh without burning CPU on every auto-save keystroke.
Works transparently in the background via register_edit — no configuration needed. When you call register_edit, any pending reindex for that file is cancelled and a fresh one is scheduled after the debounce window expires.
What you get
- 500ms debounce: rapid saves coalesce into one reindex
- Per-file queue — multiple files reindex in parallel
- asyncio-native: zero blocking on the main server thread
- Errors logged as warnings, never crash the server
- Zero configuration — active whenever register_edit is called
Ideal for: IDE setups with frequent auto-save, or any workflow where files are written rapidly during active development.
Everything above. One price.
All features included in Pyckle Pro for $20/mo. No add-ons to manage.