Pryno MCP
OfficialClick on "Deploy 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., "@Pryno MCPfind MCP servers for postgres and show readiness scores"
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.
Pryno MCP
Pryno MCP is a remote Model Context Protocol server. It lets any MCP client search the Pryno directory of public MCP servers and score a website for AI-agent readiness.
The directory is filled by a separate private crawler. This server only reads that database. It does not crawl, and it does not store CRM credentials.
Remote endpoint:
https://mcp.pryno.ai/mcpSource: github.com/Pryno-ai/pryno-mcp
Website: pryno.ai
Tools
Tool | What it does |
| Search by text, category, transport, language, official servers, or remote servers. |
| Full record for one slug, including packages and stdio install hints. |
| Categories and how many servers are in each. |
| Total servers, servers added in the last 7 days, and the last crawl time. |
| Score a public URL from 0 to 100. |
Every tool is read-only. Search and lookup results include readiness_score and last_checked_at when the crawler has stored them.
Example: search for Postgres, then open one result.
{ "query": "postgres", "limit": 5 }{ "slug": "example-postgres" }{ "url": "https://www.pryno.ai" }The readiness check fetches public files only (llms.txt, llms-full.txt, robots.txt, OpenAPI, API docs, MCP discovery, and schema.org JSON-LD). It returns pass or fail with a short summary of our own. It does not return excerpts from the target site. Private, loopback, and link-local addresses are rejected.
Resources:
pryno://directory/categoriespryno://server/{slug}
Prompt: find_mcp_server.
Related MCP server: agentalmanac-mcp
Connect
The remote URL for every client is https://mcp.pryno.ai/mcp. No API key is required.
Claude
Add a custom connector with the remote MCP URL https://mcp.pryno.ai/mcp.
ChatGPT
In developer mode, add a remote MCP server with the URL https://mcp.pryno.ai/mcp.
Cursor
{
"mcpServers": {
"pryno": {
"url": "https://mcp.pryno.ai/mcp"
}
}
}VS Code
{
"servers": {
"pryno": {
"type": "http",
"url": "https://mcp.pryno.ai/mcp"
}
}
}Local stdio
The database URL belongs in the environment that launches the process. Do not commit it.
{
"mcpServers": {
"pryno": {
"command": "npx",
"args": ["-y", "pryno-mcp"],
"env": {
"DATABASE_URL": "postgres://directory_reader@localhost:5432/pryno"
}
}
}
}You can also point the MCP Inspector at a local HTTP server:
npm run build
npm start
npx @modelcontextprotocol/inspectorConnect the inspector to http://localhost:3000/mcp.
Self-hosting
The server listens on PORT and exposes:
GET /a short descriptionGET /healthdatabase ping and schema statusPOST /mcpthe Streamable HTTP endpointGET /mcp/server-cardthe MCP server cardGET /.well-known/ai-catalog.jsona catalog entry that points at the card
docker build -t pryno-mcp .
docker run --rm -p 3000:3000 --env-file .env pryno-mcpOn Railway, use the included Dockerfile and railway.json. Keep the project private. Set variables in Railway, not in git.
This process expects the crawler's schema and a directory_reader role with SELECT only. It does not run migrations. Until those tables exist, /health still succeeds when SELECT 1 works, and the directory tools explain that the schema is not ready. run_readiness_check does not need the database.
readiness_score and last_checked_at are columns the crawler stores on servers. If they are missing, the schema is reported as incomplete.
Environment
Copy .env.example to .env. Never commit .env.
Variable | Required | Purpose |
| For directory tools | Postgres URL for the |
| No | HTTP port. Defaults to 3000. Railway sets this. |
| No | Public origin used in the server card. Defaults to |
| No | Per-IP limit for |
| No | When set, |
Development
npm ci
npm test
npm run typecheck
npm run lintTests cover tool schemas, the search query builder, the SSRF guard, and readiness scoring. They use a mocked database and do not call the network.
Available Tools
5 toolsdirectory_statsDirectory statsARead-onlyIdempotent
Return how many MCP servers are in the directory, how many were added in the last 7 days, and when the crawler last finished.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| last_crawl_at | Yes | |
| total_servers | Yes | |
| added_last_7_days | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description usefully discloses what the payload contains (counts and crawler recency), which is the main behavioral fact an agent needs for a stats call. It adds nothing about data staleness, caching, or refresh cadence beyond the crawler timestamp, and the annotations already cover the read-only/idempotent safety profile, so a 3 is appropriate.
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 with zero filler, and the three returned values are enumerated up front in the order an agent would care about them.
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?
With no inputs and an output schema present, the description only needs to say what the aggregate covers, which it does precisely. Nothing required for correct invocation is missing.
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 tool takes zero parameters, so there is no parameter semantics to explain; the baseline of 4 applies. The description correctly makes no attempt to describe arguments.
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?
Specific verb ('Return') plus the exact three data points returned: total server count, 7-day additions, and last crawler completion time. That is clearly distinguishable from list_categories, search_mcp_servers, get_mcp_server, and run_readiness_check, none of which are aggregate-statistics tools.
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 zero-parameter, aggregate nature implies when to reach for it over the list/search/get siblings, but the description never states that explicitly and names no alternatives or exclusions. Usage is inferred from the return contents rather than instructed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_mcp_serverGet MCP serverARead-onlyIdempotent
Look up one MCP server by its directory slug. Returns packages, stdio install hints, the remote endpoint, license, last activity, sources, readiness score, and when that score was last checked.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Directory slug of the MCP server. |
Output Schema
| Name | Required | Description |
|---|---|---|
| name | Yes | |
| slug | Yes | |
| tags | Yes | |
| stars | Yes | |
| license | Yes | |
| sources | Yes | |
| language | Yes | |
| packages | Yes | |
| repo_url | Yes | |
| categories | Yes | |
| remote_url | Yes | |
| transports | Yes | |
| updated_at | Yes | |
| description | Yes | |
| is_official | Yes | |
| homepage_url | Yes | |
| last_seen_at | Yes | |
| auth_required | Yes | |
| first_seen_at | Yes | |
| install_hints | Yes | |
| last_checked_at | Yes | |
| readiness_score | Yes | |
| last_activity_at | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds the returned data fields but does not disclose not-found/error behavior, rate limits, or authorization requirements. Because an output schema exists, the return list is not a major behavioral addition.
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 sentences, front-loaded with the purpose and followed by a compact return summary. No filler, and the second sentence is a useful payload preview rather than restating the name.
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?
For a simple single-record lookup with full schema coverage, annotations, and an output schema, the description covers the essential purpose and data scope. Error handling is absent, but given the structured fields and low complexity, nothing critical is missing 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 coverage is 100% for the single slug parameter, and the description's 'by its directory slug' matches the schema without adding format, casing, or validation semantics beyond what is already documented. Baseline 3 applies when the schema carries parameter documentation.
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 states a specific verb and resource: look up one MCP server by directory slug. The focus on 'one' by slug distinguishes it from the sibling search_mcp_servers, which implies query-based discovery. An agent can select this tool for known-slug retrieval without opening the schema.
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?
It implies the precondition that the caller already has a directory slug, but it does not explicitly say when to use this tool instead of search_mcp_servers or what to do if the slug is unknown. No exclusions or alternative routing are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_categoriesList categoriesARead-onlyIdempotent
List MCP directory categories and how many servers are in each.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| categories | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety behavior is covered. The description adds that results include per-category server counts, but says nothing about whether the full set is always returned or whether results are cached/aggregated. With annotations carrying the behavioral load, a 3 is appropriate.
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 with zero waste, and the resource (categories) plus the return content (server counts) are front-loaded. Nothing to trim.
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?
An output schema exists, so return shape needn't be described, and with zero parameters and no nesting the tool is simple. The only real gap is the lack of any routing cue against directory_stats, which shares the analytical/aggregate territory.
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 tool takes zero parameters, which is the baseline-4 case; the schema is fully covered and no parameter guidance is needed. The description correctly implies a no-argument, whole-directory listing.
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 gives a concrete verb+resource ('List MCP directory categories') and adds the extra payload detail ('how many servers are in each'), which distinguishes it from search_mcp_servers and get_mcp_server. It does not explicitly differentiate itself from the overlapping directory_stats sibling, so it falls short of a 5.
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?
Usage is only implied: an agent can infer this is the browsing/discovery entry point for categories. There is no explicit when-to-use, no mention of when to prefer directory_stats or search_mcp_servers, and no stated prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
run_readiness_checkRun readiness checkARead-onlyIdempotent
Score a public website from 0 to 100 for AI-agent readiness. The result lists each check as pass or fail with a short summary and the highest-value fixes. It does not return page excerpts.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Public website URL or domain to score. |
Output Schema
| Name | Required | Description |
|---|---|---|
| url | Yes | |
| host | Yes | |
| note | Yes | |
| fixes | Yes | |
| score | Yes | |
| checks | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint/idempotentHint/destructiveHint=false, so safety is covered. The description goes beyond that by disclosing the result shape ('each check as pass or fail with a short summary and the highest-value fixes') and a real negative boundary ('does not return page excerpts'), which prevents an agent from expecting page content. Minor gap: no note on failure behavior for unreachable or non-public URLs.
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?
Three short sentences, front-loaded with the core action and scoring range, then result shape, then an explicit non-capability. No filler and nothing repeated from annotations.
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?
An output schema exists, so return values needn't be enumerated, yet the description still summarizes the result usefully and rules out page excerpts. For a single-parameter tool with full annotation coverage, only error/edge-case behavior (unreachable site, non-public URL) is left unstated — a minor gap.
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 baseline would be 3; the description adds real meaning by restricting the url parameter's acceptable domain to a public website, complementing the schema's 'Public website URL or domain to score'. It does not add format or normalization details beyond the schema, so not a 5.
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?
States a specific verb ('Score'), resource ('a public website'), and output semantics ('0 to 100 for AI-agent readiness'). The function is unambiguous and none of the siblings (list_categories, search_mcp_servers, get_mcp_server, directory_stats) overlap with it.
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 word 'public' implicitly constrains when the tool is applicable, and the scope ('a public website') hints at the use case. However, there is no explicit when-to-use statement, no excluded cases (e.g. private/localhost URLs), and no named alternative — though none of the siblings are genuinely competing tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_mcp_serversSearch MCP serversBRead-onlyIdempotent
Search the Pryno MCP directory. Results include the name, slug, a one-line description, repository, remote URL, transports, stars, categories, readiness score, and when that score was last checked.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum rows to return. Defaults to 20 and cannot exceed 50. | |
| query | No | Words to match in the server name or description. | |
| cursor | No | Opaque cursor from a previous page. | |
| category | No | Category slug, such as databases or dev-tools. | |
| language | No | Primary implementation language. | |
| transport | No | Transport name, such as stdio or streamable-http. | |
| remote_only | No | When true, only servers with a remote endpoint. | |
| official_only | No | When true, only official or verified servers. |
Output Schema
| Name | Required | Description |
|---|---|---|
| servers | Yes | |
| next_cursor | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds the result field list including the freshness detail ('when that score was last checked'), which helps set expectations. However, it says nothing about result ordering, relevance ranking, or total-count/total-page behavior that the cursor parameter implies.
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 sentences, front-loaded with the purpose. The second sentence is a long field enumeration that partly duplicates the output schema, which costs a little, but nothing is padded or vague.
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?
An output schema exists, so the return-value list in the description is partly redundant and return shape needs no further explanation. With 8 optional filters and pagination, the definition is adequate but leaves result ordering and pagination completion behavior undocumented.
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% with all 8 parameters explicitly documented, including limits, cursor semantics, and example values for category, language, and transport. The description adds no parameter meaning beyond the schema, so the baseline 3 applies.
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?
States a specific verb and resource: 'Search the Pryno MCP directory.' An agent immediately knows this is a filtered search over a server catalog. It doesn't differentiate itself from siblings like get_mcp_server or directory_stats, so it stops short of a 5.
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?
There is no when-to-use or when-not-to-use guidance and no mention of alternatives. An agent must infer from the name alone that get_mcp_server is for fetching a single known server and list_categories for category enumeration. The description provides no routing signal.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
5 tool updates
v0.1.0- First observed
directory_stats - First observed
get_mcp_server - First observed
list_categories - First observed
run_readiness_check - First observed
search_mcp_servers
TDQS
Scored across 5 tools
Each tool has a distinct target: directory browsing (list_categories), querying (search_mcp_servers), single lookup (get_mcp_server), aggregate metrics (directory_stats), and an external scoring function (run_readiness_check). The only mild overlap is between list_categories and directory_stats, both of which surface counts, and between the 'readiness score' returned by lookup tools versus the standalone check tool. Descriptions make the boundary clear enough that misselection is unlikely.
Four of five names follow a verb_noun or verb_object pattern (list_categories, search_mcp_servers, get_mcp_server, run_readiness_check) with consistent snake_case. directory_stats breaks the pattern by being noun-only with no verb, a minor deviation. Overall readable and predictable.
Five tools is a tight, well-scoped surface for a read-only directory server: browse, search, lookup, aggregate stats, and one scoring utility. No tool appears redundant or padded, and nothing feels conspicuously absent at the count level.
The read-only lifecycle of a directory is well covered: discovery via search, detail via get, taxonomy via list_categories, and health via directory_stats. Minor gaps exist — there's no explicit way to enumerate servers within a category (you must fall back to search) and no compare/batch lookup, but agents can work around these.
Maintenance
Related MCP Connectors
Search a nightly-refreshed directory of MCP servers by keyword, category or topic.
Agent-first search of MCP servers, APIs, CLIs and skills, with best picks and transparent scores.
Search, vet & assemble MCP servers from your agent: verified tools, risk labels, and trust scores.
Live index of AI agents, MCP servers and tools with observed liveness and capability search.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables AI assistants to search, compare, and get detailed information about MCP servers from the mcpcatalogs.com directory.45 npmMIT
- AlicenseAqualityDmaintenanceEnables searching and retrieving details of 9,000+ MCP servers from the Agent Almanac catalog, allowing agents to discover, inspect, and install tools directly.339 npmMIT
- AlicenseAqualityFmaintenanceEnables AI agents to search a directory of 13,870+ MCP servers, 4,384+ agent skills, and plugins from Remote OpenClaw, returning install commands directly.349 npm6MIT
- FlicenseNot gradedqualityDmaintenanceFinds the right MCP server for a task from over 1,400 indexed servers ranked by community trust. Also provides outcome-ranked web search for AI agents with no API key or rate limits.4-