> For the complete documentation index, see [llms.txt](https://pharaoh.so/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://pharaoh.so/docs/tools-reference/overview.md).

# Overview

Pharaoh exposes MCP tools that your AI agent calls automatically. They fall into four categories: **Orient** (understand the codebase), **Investigate** (trace impact), **Audit** (sweep for problems), and **Manage** (account and configuration).

Free-tier tools are always available. Pro tools return a preview on the free tier - enough to show what the data looks like - with full results on Pro.

## All Tools

| Tool                              | Category    | Tier | Description                                                                                                        |
| --------------------------------- | ----------- | ---- | ------------------------------------------------------------------------------------------------------------------ |
| `pharaoh_recon`                   | Orient      | Free | Batched reconnaissance — codebase map + module context + function search + blast radius in one call                |
| `get_codebase_map`                | Orient      | Free | Full structural overview — modules, dependency graph, entry points, hot files                                      |
| `get_module_context`              | Orient      | Free | Complete module profile — files, functions, DB tables, endpoints, env vars, external callers                       |
| `search_functions`                | Orient      | Free | Search all functions across the codebase before creating duplicates                                                |
| `get_design_system`               | Orient      | Free | Discover design system components, tokens, and anti-patterns before creating UI                                    |
| `get_blast_radius`                | Investigate | Free | Trace all downstream callers before refactoring — endpoints, cron jobs, DB operations affected                     |
| `query_dependencies`              | Investigate | Free | Trace how any two modules connect — forward, reverse, circular, shared dependencies                                |
| `trace_flow`                      | Investigate | Free | Walk a function's call tree to understand how a feature works — signatures, docs, and connections at every step    |
| `check_reachability`              | Investigate | Pro  | Verify functions are wired to production entry points (API endpoints, CLI, cron handlers, MCP tools)               |
| `get_vision_docs`                 | Investigate | Pro  | Compare CLAUDE.md files and PRDs against actual implementation                                                     |
| `get_vision_gaps`                 | Audit       | Pro  | Find specs without code AND complex code without specs                                                             |
| `get_cross_repo_audit`            | Audit       | Pro  | Compare two repositories for code duplication and structural overlap                                               |
| `get_consolidation_opportunities` | Audit       | Pro  | Find duplicate code, parallel consumers, competing DB access, signature twins                                      |
| `get_unused_code`                 | Audit       | Pro  | Find functions unreachable from any production entry point with text-reference backup verification                 |
| `get_test_coverage`               | Audit       | Pro  | Per-module coverage summary — which files have tests, which high-complexity functions lack them                    |
| `get_regression_risk`             | Audit       | Pro  | Score functions by likelihood of breaking production — complexity, exposure, churn, caller count                   |
| `request_upload`                  | Manage      | Free | Get a presigned URL to upload parsed codebase data — map repos without the GitHub App                              |
| `map_open_source_repo`            | Manage      | Free | Map any public GitHub repo into Pharaoh so you can query its architecture with all analysis tools                  |
| `setup_environment`               | Manage      | Free | Install Pharaoh's curated plugin bundle — LSP, security scanning, code review, tailored to your codebase languages |
| `pharaoh_account`                 | Manage      | Free | Manage subscription, toggle PR Guard, trigger graph refreshes                                                      |
| `pharaoh_feedback`                | Manage      | Free | Report false positives or provide feedback on tool results                                                         |
| `pharaoh_admin`                   | Manage      | Free | Administrative operations for org management                                                                       |
| `get_pharaoh_docs`                | Manage      | Free | Query Pharaoh's own documentation — setup, tools, security, pricing, troubleshooting                               |

## Category guides

* [Orient Tools](/docs/tools-reference/orient.md) - understand the codebase before changing it
* [Investigate Tools](/docs/tools-reference/investigate.md) - trace impact before committing
* [Audit Tools](/docs/tools-reference/audit.md) - sweep for drift, duplication, and risk
* [Manage Tools](/docs/tools-reference/manage.md) - account, uploads, and configuration


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://pharaoh.so/docs/tools-reference/overview.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.