Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    gemma code search

    1

    Semantic code search for repositories using AST-aware chunking and Google EmbeddingGemma-2.

    Free

    Security scanned
    gemma code search

    gemma code search

    Example session with this skill installed

    Find the implementation of the JWT token refresh logic in the backend.

    • Read your context and instructions
    • Compiled the gemma code search

    Searching for "JWT token refresh logic" in the current repository...
    Found 2 matches across 2 files.

    Search Results

    ScoreFile PathScopeSnippet
    0.892src/auth/service.pyAuthService.refresh_sessiondef refresh_session(self, token: str):\n claims = self.jwt.decode(token)\n if claims.is_expired():\n raise Unauthorized()\n return self.issue_pair(claims.user_id)
    0.845src/middleware/auth.tsverifyRefreshTokenexport const verifyRefreshToken = (req: Request) => {\n const token = req.cookies['refresh_token'];\n if (!token) return null;\n return jwt.verify(token, process.env.REFRESH_SECRET);\n};

    => [...] continue reading in <src/auth/service.py>: lines 140-210 (query matched 142-148)

    Next steps

    • Run code-search index --paths src/auth/service.py if you just modified the refresh logic.
    • Inspect the full implementation in src/auth/service.py at line 140 to see the issue_pair method.
    • Use code-search "JWT secret configuration" to find where the environment variables are loaded.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Finding logic in a massive codebase shouldn't feel like guessing regex patterns. Grep fails when you don't know the exact variable names, and standard LLM context limits break on large repos. This skill provides semantic code search that understands intent, not just strings.

    What it does

    • Semantic search finding code by meaning or behavior using Google EmbeddingGemma-2.
    • AST-aware chunking breaking files into logical functions, classes, and methods for precise results.
    • Hybrid ranking fusing exact symbol matches with semantic vectors to ensure high recall.
    • Incremental indexing updating only what has changed based on git commits to save time.
    • Cross-language support handling Python, JS/TS, Go, Rust, PHP, and Markdown.

    How it works

    1. Index initialization using code-search index --force to build the initial vector store of your repo.
    2. Natural language query running code-search "your query" to find relevant code snippets.
    3. Targeted updates using --paths to re-index specific files after you make edits.
    4. Daemon management controlling the shared model process that stays in RAM for fast subsequent searches.

    Frameworks & tools

    Built with Python and Tree-sitter for syntax-tree parsing. It uses the Google EmbeddingGemma-2 model with either a Torch or ONNX backend, optimized for both GPU and CPU-only environments.

    Why this beats prompting it yourself

    Raw prompts lack the context of an entire repository and suffer from hallucinated file paths. This skill provides a grounded search index that maps your intent to actual code chunks, ensuring you work with the real source of truth rather than a model's guess.

    Use cases

    • Locating specific logic like "rate limiting" or "auth middleware" across unfamiliar microservices.
    • Understanding how complex tokens or session handlers are managed throughout the stack.
    • Discovering existing utility functions to prevent code duplication in large teams.
    • Scanning documentation files for architectural decisions using natural language.

    Known limitations

    Does not auto-reindex dirty or uncommitted files during a standard search. Large text files are split by token limits rather than syntax trees. Requires a manual rebuild if switching between Torch and ONNX backends.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for LLM Ops.

    Standard search excludes uncommitted changes. Documentation files lack AST chunking. Switching backends requires a full index rebuild. Indexing never auto-resumes after a crash without manual retry.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 8 days ago

    • Free with an Agensi account

    Accounts
    Astral
    Software
    ruffuv (Python tool runner)PythonGit

    Permissions

    Terminal / Shell
    Network Access
    Read Files
    Write Files
    Environment Variables

    Allowed Hosts

    astral.sh
    Listed8 days ago

    What's inside

    Frequently Asked Questions

    Unlike grep or basic search, this skill uses Google EmbeddingGemma-2 to understand the intent behind your query, meaning you can find 'authentication logic' even if that specific phrase isn't in the code. Additionally, it uses AST-aware chunking to ensure search results return complete, logical blocks like whole functions or classes rather than fragmented lines.

    This skill is optimized for Python, JavaScript/TypeScript, Go, Rust, and PHP by using Tree-sitter for intelligent parsing. It also supports Markdown files for searching through project documentation and architectural notes.

    The skill includes a built-in daemon that keeps the EmbeddingGemma-2 model in RAM, ensuring that once the initial index is built, subsequent semantic searches return results in milliseconds. To keep the index current, you can perform incremental updates based on git commits rather than re-indexing the entire repository.

    You can run this skill in both GPU-accelerated environments using Torch or on CPU-only machines using the ONNX backend. It is designed to work as a standalone CLI tool or as a background service for AI agents that need to reference your local codebase during a chat session.

    The purchase provides full access to the gemma-code-search tool, including the AST-aware chunking engine, the integration logic for Google EmbeddingGemma-2, and the indexing management system. Updates are handled via the marketplace's standard versioning system, allowing you to pull the latest performance optimizations and language parsers.

    New in LLM Ops

    Free