Fossick

by lipdog

Not rated
GitHub

About

Search all of GitHub from your AI agent — find libraries, drill into repos, find code patterns.

Details

Author
lipdog
Categories
Developer Tools, Other, Search, Knowledge Base

Setup

Install Fossick in your MCP client (Claude Desktop, Cursor, Windsurf, and others).

Repository: https://github.com/lipdog/fossick-mcp

Follow the installation instructions in the repository README, then restart your MCP client.

Prospect across all of GitHub from your AI agent.

Find libraries, discover gems, search code patterns, and read real production code — across 200M+ repos, PyPI, and npm.

- What is Fossick
-
Examples
-
Installation
-
Tools
-
Why Fossick
-
FAQ
-
Configuration
-
Development
-
License

fossick/ˈfɒsɪk/verb(Australian/NZ) — to prospect or rummage for gems, especially the small-scale kind of mining where you sift creek beds and old tailings looking for what bigger operators missed.

That's exactly what this tool does — but for code.

Fossick gives your AI agent seven read-only tools toprospect across all of GitHub, PyPI, and npm, covering the full discovery loop end-to-end:
- Search and discover.Sift 200M+ repos with multi-query relevance ranking, find the small-but-good libraries that bigger tools bury, look up packages on PyPI and npm.
- Drill into any repo without cloning.Browse a remote repo's tree with depth and glob filters, read any file at any branch/tag/commit, and goto-definition for any class, function, or type — all on remote GitHub, no local checkout needed.
- Search code patterns across all of GitHub.Full-text, regex, qualifier-aware search across every public file — find how an API isactuallyused in production, not just in the docs.

Useful any time you'd benefit from your agent reaching into the world's largest code corpus:

- Pick the right library.Find a small, focused, actively-maintained option for any task — not just the most popular one.
- Discover hidden gems.Surface the 500-star library that ranks higher onrelevancethan the 50,000-star incumbent.
- Drill into a repo you found.Walk its layout, read its README, find where its core API is defined — withoutgit clone.
- Find usage patterns in real code.Search how an API is called in production, then read the matched files in context.
- Get inspired.See how others structured similar projects, what patterns they used, what tradeoffs they made.
- Stay current.Discover what's trending, just-released, or new in an ecosystem — past your model's training cutoff.

It doesnotdo code archaeology — git blame, PR history, version diffs. Reach forgitandghfor that.

Once Fossick is connected, here's the kind of thing you can ask your agent.

- "Find me a small, actively-maintained Rust TUI library — something newer than ratatui."
- "What are people using instead of LangChain these days?"
- "Show me trending Python web frameworks released in the last 90 days."
- "What's a good lightweight alternative to Pydantic for runtime validation?"

- "Browse the structure ofastral-sh/uv— what's incrates/?"
- "Read the main__init__.pyfrompydantic/pydantic."
- "Where is theStreamclass defined inanthropics/anthropic-sdk-python?"
- "What's the latest release ofmodelcontextprotocol/python-sdkand when did it ship?"

- "How do production FastAPI apps actually set up structured logging withstructlogandasyncio?"
- "Show me real examples oftokio::select!being used with timeout cancellation."
- "Find Dockerfiles that build multi-stage Python images withuv."
- "How are people calling the OpenAI API streaming endpoint from Go?"

- "Is therequestslibrary still maintained?"
- "Compare freshness ofhttpxvsaiohttp— last release dates, recent activity."
- "Who actually usesmsgspec? Show me real usage in production codebases."
- "Find the GitHub repo behind thepolarsPyPI package and check its last release."

Prerequisite:uv— install withcurl -LsSf https://astral.sh/uv/install.sh | sh. Thenuvxwill download and run Fossick on demand. No clone needed.

Three install scopes. Pick the one that matches how you want Fossick to be available — globally, shared with your team, or just for you in one project. The scope flag controls where the config gets written (Claude Code MCP scopes).

Available inevery projecton your machine. Stored in~/.claude.json, private to your user account.

claude mcp add fossick --scope user uvx fossick-mcp

Stored in.mcp.jsonat the project root,checked into version control. Anyone who clones the repo gets the same MCP server. Use this when the whole team should have Fossick.

claude mcp add fossick --scope project uvx fossick-mcp

Local scopeis the default. Only enabled in the current project, only for you. Stored in~/.claude.jsonunder this project's path — not committed, not shared with collaborators.

If you'd rather skip the CLI, write the config yourself. The JSON shape is the same regardless of scope — only the file changes:

- ~/.claude.jsonfor user / local scope
- .mcp.json(project root) for project scope

{ "mcpServers": { "fossick": { "command": "uvx", "args": ["fossick-mcp"] } } }

Or add manually to~/.cursor/mcp.jsonor.cursor/mcp.json:

{ "mcpServers": { "fossick": { "command": "uvx", "args": ["fossick-mcp"] } } }
code --add-mcp '{"name":"fossick","command":"uvx","args":["fossick-mcp"]}'

Edit~/Library/Application Support/Claude/claude_desktop_config.json(macOS) or%APPDATA%\Claude\claude_desktop_config.json(Windows):

{ "mcpServers": { "fossick": { "command": "uvx", "args": ["fossick-mcp"] } } }

Edit~/.codeium/windsurf/mcp_config.json:

{ "mcpServers": { "fossick": { "command": "uvx", "args": ["fossick-mcp"] } } }

Editcline_mcp_settings.jsonvia the Cline extension's MCP settings panel:

{ "mcpServers": { "fossick": { "type": "stdio", "command": "uvx", "args": ["fossick-mcp"] } } }
codex mcp add fossick -- uvx fossick-mcp
[mcp_servers.fossick] command = "uvx" args = ["fossick-mcp"]
git clone https://github.com/Lipdog/fossick-mcp.git cd fossick-mcp uv sync

Then point your MCP config at the local clone:

{ "mcpServers": { "fossick": { "command": "uv", "args": ["run", "--directory", "/path/to/fossick-mcp", "fossick-mcp"] } } }

Seven read-only tools, organized by their role in the discovery workflow.

All tools areread-only, idempotent, and safe to auto-approve. Every response ends with hint-chained next steps so the agent knows what to do next.

- Built for the discovery workflow.Tools follow the natural shape: find candidate → drill into it → read the API → see how others use it. Hint-chained next-step suggestions keep your agent on rails through the whole loop.
- Drill into any public repo without cloning.Browse remote repo trees with depth + glob filters, read any file at any branch/tag/commit, and run real AST-based symbol search to goto-definition for any class, function, or type — all on remote GitHub.
- Multi-query search with smart ranking.search_reposaccepts a list of phrasings in one call and applies composite relevance ranking that prioritizes literal match over raw popularity — surfaces the 500-star gem that beats the 50,000-star incumbent.
- Lean on tokens by design.7 focused tools (not 30+), formatted-markdown outputs (not JSON dumps), TTL caching, hint chaining that cuts agent reasoning turns, and multi-query search that bundles N requests into 1. Every tool description and response is sized to keep your context budget free for real work.
- Rate-limit aware.Tracks GitHub's Search and Core API buckets separately, sleeps on exhaustion, retries with exponential backoff.
- Zero config forghusers.Already have the GitHub CLI authenticated? Nothing to configure.
- Plays well with others.Read-only, idempotent, safe to auto-approve. Pair Fossick withgithub-mcp-serverwhen you also need to act on your own repos (issues, PRs, Actions).

Yes — without one you'll hit GitHub's 60-requests-per-hour unauthenticated limit almost immediately. The easiest path is to install theGitHub CLIand rungh auth loginonce. Fossick picks up your token automatically. No need to pass anything in the MCP config.

uvxruns Fossick in a transient, isolated environment without polluting your global Python. It downloads on first use, caches for subsequent runs, and updates effortlessly. You also don't need to manage a virtualenv or worry about Python version conflicts. If you'd rather use pip,pip install fossick-mcpworks — just point your MCP client at the installedfossick-mcpbinary.

Yes. Every search, file fetch, and tag list counts against your token's rate limits. Fossick splits requests across two buckets — Search API (30/min) and Core API (5,000/hr) — and pauses automatically when either is exhausted. For most discovery sessions you'll never hit the limits.

If your client supports the standard MCPstdiotransport, yes. The standarduvx fossick-mcpconfig works in Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, Cline, Codex, and most others. See theInstallationsection for client-specific snippets.

Only those your GitHub token can access. The token's permissions are the only constraint — Fossick doesn't have its own ACL layer. If your token can read a private repo, Fossick can search it; if not, it can't.

Deliberate scope decision. Code archaeology (who changed what, why, when) is a different shape of problem and is well-served bygitand theghCLI. Fossick stays focused on the discovery workflow — finding and evaluating, not investigating.

Live from GitHub on every request. Fossick caches results briefly to avoid hammering the API on repeated identical calls, with longer TTLs for content pinned to a specific commit SHA. Anything past the TTL is a fresh fetch.

Fossick resolves a GitHub token automatically:
- GH_TOKEN,GITHUB_TOKEN, orGITHUB_PERSONAL_ACCESS_TOKENenv vars
- gh auth tokenfrom the
GitHub CLI—no config needed if you're already logged in

{ "mcpServers": { "fossick": { "command": "uvx", "args": ["fossick-mcp"], "env": { "GITHUB_TOKEN": "ghp_your_token_here" } } } }

A token only needs public repo read access (no scopes selected is fine).

Fossick tracks both GitHub API buckets and pauses automatically when either is exhausted.

Retries use exponential backoff on rate-limited and transient errors. Results are cached briefly to avoid redundant API calls, with longer TTLs for content pinned to a specific commit SHA.

git clone https://github.com/Lipdog/fossick-mcp.git cd fossick-mcp uv sync

Launch the MCP server on stdio (for manual testing or local MCP-client config):

Unit and registration tests — no network, runs in seconds:

Live integration tests — hits real GitHub against pinnedmodelcontextprotocol/python-sdk@v1.14.0:

Producesdist/fossick_mcp-<version>.tar.gzand the corresponding wheel.

SeeCLAUDE.mdfor the full architecture tour, key patterns, and the recipe for adding new tools.

This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.

A server for code indexing, searching, and analysis, enabling LLMs to interact with code repositories.

Semantic code search for AI agents without indexing your codebase or storing any data. Fast and accurate.

Create and read feature flags, review experiments, generate flag types, search docs, and interact with GrowthBook's feature flagging and experimentation platform.

Word search, crossword, and sudoku generator MCP server with printable PDF worksheets, themed word banks, and verifiable LLM evals. Local-first, from the makers of puzzletide.com.

Official MCP server for Stimulsoft Reports & Dashboards documentation. Semantic search across FAQ, Programming Manual, Server/User Manual, and Server/Cloud API for .NET, WPF, Avalonia, WEB, Blazor, Angular, React, JS, PHP, Java, and Python platforms.

Persistent code index using Tree-sitter for fast, precise code search. Replaces grep with ~50 token responses instead of 2000+.

Searching and access your AI coding sessions from Claude Code, Gemini CLI, opencode, and OpenAI Codex.

Search Apple's Developer Documentation with smart search and wildcard support.

MCP server that exposes ast-grep (sg) as two tools for structural code search.

A platform-agnostic code analysis library with semantic search capabilities and MCP server support.

No reviews yet — be the first

Sign in to leave a review

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.