Fossick

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.

Contents

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

What is Fossick

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 to prospect across all of GitHub, PyPI, and npm, covering the full discovery loop end-to-end:

1. 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.
2. 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.
3. Search code patterns across all of GitHub. Full-text, regex, qualifier-aware search across every public file — find how an API is actually used 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 on relevance than the 50,000-star incumbent.
• Drill into a repo you found. Walk its layout, read its README, find where its core API is defined — without git 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 does not do code archaeology — git blame, PR history, version diffs. Reach for git and gh for that.

Examples

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

Discover libraries and packages

• "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?"

Drill into a specific repo

• "Browse the structure of astral-sh/uv — what's in crates/?"
• "Read the main __init__.py from pydantic/pydantic."
• "Where is the Stream class defined in anthropics/anthropic-sdk-python?"
• "What's the latest release of modelcontextprotocol/python-sdk and when did it ship?"

Find code patterns in the wild

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

Vet a dependency before adopting it

• "Is the requests library still maintained?"
• "Compare freshness of httpx vs aiohttp — last release dates, recent activity."
• "Who actually uses msgspec? Show me real usage in production codebases."
• "Find the GitHub repo behind the polars PyPI package and check its last release."

Installation

Prerequisite: uv — install with curl -LsSf https://astral.sh/uv/install.sh | sh. Then uvx will download and run Fossick on demand. No clone needed.

Claude Code

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).

Global (recommended for personal use)

Available in every project on your machine. Stored in ~/.claude.json, private to your user account.

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

Team-shared (committed to git)

Stored in .mcp.json at 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

This project only (default)

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

claude mcp add fossick uvx fossick-mcp

Manual install

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.json for user / local scope
• .mcp.json (project root) for project scope

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

Other clients

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

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

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

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

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

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

Tools

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

Find candidates