Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@herohunt-mcp Find me 5 senior Go engineers in Berlin and summarize the top 3."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP server for the HeroHunt People Search API. Search for talent across LinkedIn, GitHub, and StackOverflow from any MCP-compatible AI agent.
Claude Desktop, Cursor, and most modern MCP clients support remote HTTP endpoints directly. No package installation needed.
Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json):
{
"mcpServers": {
"herohunt-people-search": {
"url": "https://api.herohunt.ai/api/v1/mcp",
"headers": {
"Authorization": "Bearer YOUR_API_KEY"
}
}
}
}Cursor (~/.cursor/mcp.json):
{
"mcpServers": {
"herohunt-people-search": {
"url": "https://api.herohunt.ai/api/v1/mcp",
"headers": {
"Authorization": "Bearer YOUR_API_KEY"
}
}
}
}For MCP clients that only support stdio transport:
{
"mcpServers": {
"herohunt-people-search": {
"command": "npx",
"args": ["-y", "herohunt-mcp"],
"env": {
"HEROHUNT_API_KEY": "YOUR_API_KEY"
}
}
}
}Related MCP server: candidate-mcp-server
Sign up at herohunt.ai/app/api/sign-up to get your API key.
Tool | Type | Description |
| Write | Search for people profiles using natural language. 1 credit per reserved slot. |
| Read | Fetch more results for an existing search. Free unless enrichment is on. |
| Read | Get plan, credits, rate limit info. Free. |
| Read | List past searches. Free. |
| Read | Get plan upgrade URL. Free. |
| Read | Get Stripe billing portal URL. Free. |
| Read | List API key prefixes and scopes. Free. |
| Write | Create a new API key. |
| Write | Rotate an existing API key. |
| Write | Permanently revoke an API key. |
After connecting, ask your AI agent:
"Use HeroHunt to find me 5 senior Go engineers in Berlin and summarise the top 3."
The agent will call people_search with a natural language query, receive structured profile data (name, title, company, location, skills, platform links), and summarize the results.
To get contact info, ask:
"Enrich the results with emails and phone numbers."
The agent will call people_search_paginate with enrich: true.
Variable | Required | Default | Description |
| Yes | - | Your People Search API key |
| No |
| Override the MCP endpoint URL |
MIT
Get Stripe Customer Portal URL for managing subscriptions. Free.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations, so description carries burden. States it returns a URL and is free, but lacks details on authentication, side effects, or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no superfluous words. Efficient and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Tool is simple (no params, no output schema). Description covers purpose but lacks details on prerequisites, response format, or error cases. Adequate but could be more complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist (schema coverage 100%), so baseline is 4. Description adds nothing beyond schema, but parameter semantics are not needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it gets a Stripe Customer Portal URL for managing subscriptions, and the 'Free' note adds context. It distinguishes from sibling tools like account_upgrade_link.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. Only implies usage for managing subscriptions, but no when-not or sibling differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List past searches with first-page profiles. Free.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | History page. | |
| limit | No | Number of past searches (default 20). | |
| includeLogs | No | Include pipeline logs. | |
| per_search_page | No | Profiles per past search (default 10). | |
| returnAllProfiles | No | Include all profiles per search. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It mentions 'Free' but does not describe rate limits, whether it is read-only, or what happens if no searches exist. The listing nature is implied but not explicitly stated as safe.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise with two short sentences. It front-loads the core action. The word 'Free' is arguably unnecessary but does not harm conciseness. However, it could be slightly more informative without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters and no output schema, the description should explain return values, pagination behavior, and how it relates to sibling tools like 'people_search'. It lacks sufficient context for an agent to use it correctly without guessing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with descriptions for all 5 parameters. The description adds no additional meaning beyond the schema. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List past searches with first-page profiles,' using a specific verb and resource. It distinguishes from sibling tools like 'people_search' which search people, not list past searches. However, it could be more precise about what 'first-page profiles' means.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as 'people_search_paginate' or 'account_usage_get'. There is no mention of prerequisites or scenarios where this tool is preferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a dashboard URL prefilled with account email for plan upgrades. Free.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description alone must convey behavioral traits. It does not disclose side effects, authentication requirements, rate limits, or what happens if the account is ineligible for upgrades. The security implications of a URL prefilled with an email are not addressed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. It efficiently communicates the tool's action and purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters, no output schema), the description is moderately complete. It covers the primary function but omits details like how the URL is obtained (e.g., API call, redirect), prerequisites, and its relationship to the sibling account_billing_portal_link. An AI agent might need more context for proper selection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters (100% coverage by default). Baseline for 0 params is 4. The description adds context by specifying the URL's purpose (plan upgrades) and that it's free, which adds meaning beyond the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description states 'Get a dashboard URL prefilled with account email for plan upgrades.' The verb 'Get' and resource 'dashboard URL' are clear, and 'plan upgrades' specifies the purpose. It distinguishes from sibling account_billing_portal_link by focusing on upgrades and noting 'Free.' However, it does not explicitly define which account (the authenticated user's), which leaves minor ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description includes 'Free' as a hint about cost but provides no guidance on when to use this tool versus alternatives like account_billing_portal_link or other upgrade paths. No explicit use cases, prerequisites, or exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get plan, total/used/remaining credits, rate limit, and next credit reset date. Free.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must disclose behavior. It says 'Free' (likely no credit cost), but does not state authentication requirements, read-only nature, or any limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no redundant words. Lists specific data items efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, so description must explain return values. It covers the main elements but lacks detail on data types or structure. Adequate for a simple read operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, so schema coverage is 100%. Description adds value by listing the output fields (plan, credits, rate limit, reset date) beyond the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it retrieves plan, credits, rate limit, and reset date. Implicitly distinguishes from sibling tools like account_upgrade_link and account_billing_portal_link by listing specific data fields, but no explicit differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. For example, no mention of whether this is a quick check or a prerequisite for other account actions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a new API key. Full key is returned only once. Store it immediately.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Friendly name for the key (e.g. "CI Bot"). | |
| scopes | No | Permission scopes. Defaults to people:search. | |
| expiresAt | No | ISO-8601 expiry date (optional). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; the description discloses a key behavioral trait (key returned once, store immediately) but omits other details like authentication requirements or error handling, which are expected for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, each critical: the first states the action, the second provides essential warning. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description explains the critical return behavior. It covers the core purpose and warning, though it could mention error scenarios or idempotency.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents parameters. The description adds no additional meaning beyond what is in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool creates an API key and adds critical context about the key being returned only once and needing immediate storage, distinguishing it from siblings like api_keys_list, rotate, and revoke.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use (when a new API key is needed) and includes a storage warning, but does not explicitly mention when not to use or compare with alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List API key prefixes, scopes, and last-used timestamps.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It implies a read-only operation (listing), but does not explicitly state it is non-destructive, idempotent, or any other behavioral traits (e.g., rate limits, auth needs). Minimal transparency beyond the core purpose.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that is front-loaded with the verb 'List' and describes the resource and returned fields. Every word contributes meaning; no wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no parameters, no output schema, and minimal annotations, the description is adequate but has gaps. It lists returned fields but does not explain return format, pagination, or ordering. Suitable for a simple list, but could be more complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so the baseline is 4. The description adds no parameter information, but none is needed. It does not enrich beyond the schema but meets the baseline for parameterless tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description specifies the verb 'List' and the resource 'API keys' with specific fields (prefixes, scopes, timestamps). It clearly differentiates from sibling tools like api_keys_create and api_keys_revoke by indicating a read-only listing operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. The description only states what it does, lacking explicit context for when-not-to-use or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Permanently revoke an API key. Irreversible.
| Name | Required | Description | Default |
|---|---|---|---|
| keyId | Yes | ID of the key to revoke. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description must disclose behavior. It clearly states 'Permanently revoke' and 'Irreversible', highlighting destructive nature. However, it omits details like required authentication, error handling if key not found, or side effects on active sessions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise with two short sentences. Front-loaded with the core action. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the irreversible nature and no output schema or annotations, the description is too brief. It lacks information about success/failure responses, error conditions, or confirmation steps. Leaves gaps for a critical operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers the single required parameter 'keyId' with description. The tool description adds emphasis on irreversibility but no additional semantic context for the parameter beyond what schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the action (revoke) and resource (API key), distinguishing it from sibling tools like api_keys_list, api_keys_create, and api_keys_rotate. The word 'Permanently' and 'Irreversible' add specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives (e.g., rotate vs revoke). No prerequisites or conditions like key must exist or be active.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Rotate an API key: deactivate old, issue new with same scopes.
| Name | Required | Description | Default |
|---|---|---|---|
| keyId | Yes | ID of the key to rotate. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It accurately states that the old key is deactivated and a new one is issued with the same scopes, but it does not detail consequences (e.g., immediate invalidation of the old key, whether the new key's secret is returned) or any authorization requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, consisting of a single sentence with a colon to separate purpose and behavior. Every word contributes meaning, and the structure is front-loaded and clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no output schema, no annotations), the description covers the core action adequately. However, it could be improved by mentioning what is returned (e.g., new key details) or any side effects like old key immediate expiration.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the description adds no extra meaning beyond the schema's parameter description ('ID of the key to rotate'). The tool has a single parameter, and the description does not enhance understanding of its usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Rotate an API key') and specifies the outcome ('deactivate old, issue new with same scopes'). It uniquely identifies the tool's purpose and distinguishes it from sibling tools like api_keys_create and api_keys_revoke.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for rotating keys while preserving scopes, but it does not provide explicit guidance on when to use it versus alternatives (e.g., when to rotate vs. revoke and recreate). No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for people profiles using natural language across LinkedIn, GitHub, and StackOverflow. Credits: 1 per reserved slot up front (default maxResults=100). Enrichment: +1 credit per LinkedIn profile with contact info.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | Page number. | |
| query | No | Natural language query. Required for new searches. | |
| enrich | No | Request email/phone enrichment for LinkedIn profiles. | |
| filters | No | Structured filters. | |
| per_page | No | Results per page (max 50, default 10). | |
| searchId | No | Existing search ID for pagination. | |
| timeoutMs | No | Max wait time in ms. | |
| maxResults | No | Max profiles to collect (default 100). Charged up front. | |
| includeLogs | No | Include pipeline trace logs. | |
| returnAllProfiles | No | Return all matched profiles, not just current page. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses credit costs and default maxResults, but fails to mention timeout behavior, error handling, or that searchId is used for pagination. Some behavioral traits are missing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences covering purpose and cost. It is front-loaded but could be slightly more structured to include usage tips without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 10 parameters, no output schema, and no annotations, the description omits important details about return values, pagination, and error states. It is incomplete for a tool of this complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the description adds limited value beyond schema descriptions. It ties credits to maxResults but does not explain relationships between parameters like query and searchId.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches for people profiles using natural language across specific platforms (LinkedIn, GitHub, StackOverflow), distinguishing it from the sibling 'people_search_paginate' which likely handles pagination.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides cost context (credits per reserved slot and enrichment), but does not explicitly state when to use this tool vs alternatives like 'people_search_paginate'. It lacks when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch additional pages for an existing search. Free unless enrich is enabled.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | Page number. | |
| enrich | No | Request enrichment (+1 credit per enriched profile). | |
| per_page | No | Results per page. | |
| searchId | Yes | ID of existing search to paginate. | |
| includeLogs | No | Include pipeline logs. | |
| returnAllProfiles | No | Return all matched profiles. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The only behavioral trait disclosed is cost ('Free unless enrich is enabled'). No mention of idempotency, error handling, rate limits, or what happens if searchId is invalid. Given no annotations, the description carries full burden but fails to provide sufficient transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one sentence, front-loaded with the action. It is concise and no extra fluff, though a bit more structure (e.g., requirements) would be beneficial.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 6 parameters, no output schema, and no annotations. The description covers only the basic purpose and cost. It lacks context on how pagination works, relationship to searchId, and parameter defaults, leaving gaps for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds only the cost note related to the 'enrich' parameter, but otherwise does not add meaning beyond what is in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Fetch additional pages for an existing search', which is a specific verb and resource. It distinguishes from the sibling tool 'people_search' by emphasizing pagination of an existing search, though it does not explicitly differentiate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, no prerequisites or when-not-to-use conditions. Only a vague implication that it is for additional pages after an initial search.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.2account_billing_portal_linkaccount_searches_listaccount_upgrade_linkaccount_usage_getapi_keys_createapi_keys_listapi_keys_revokeapi_keys_rotatepeople_searchpeople_search_paginateScored across 10 tools
Tools are cleanly separated across three domains: people search, account management, and API keys. The two search tools are distinct (initial search vs. pagination), and account and API key tools have clearly different purposes. No overlapping or ambiguous functions.
All tools follow a consistent verb_noun pattern in snake_case, e.g., people_search, account_usage_get, api_keys_create. The naming style is uniform and predictable, with minor but acceptable variation in verbs (get, list, create, etc.).
10 tools is well-scoped for a server combining people search, account management, and API key management. Each tool serves a distinct and necessary function, with no redundancy or excessive granularity.
The set covers core workflows: search with pagination, account usage and history, billing and upgrade links, and full CRUD for API keys. Minor gaps include no direct profile detail retrieval (beyond search results) and no API key scope update (rotate reuses same scopes).
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Query professional profiles, search candidates, and get AI-powered summaries and job fit analysis.
Search people open to work and fetch their machine-readable cv.json, from any AI assistant.
Search companies, enrich contacts, and reveal emails and phones from your AI agent.
The open-source talent graph for humans and AI agents. Find developers.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/herohunt-ai/herohunt-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
