PawnDex MCP Server
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., "@PawnDex MCP Serversearch for mysql packages by user:openmultiplayer"
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.
PawnDex MCP Server
A Model Context Protocol (MCP) server for PawnDex, the Pawn package index for the SA-MP / open.mp ecosystem.
This server enables AI assistants (like Claude) to:
Search for Pawn packages with various filters.
Inspect detailed information about specific repositories, including releases and tags.
Retrieve global statistics and supported languages.
Tools
search_packages: Search for packages using queries likemysql,is:official,user:openmultiplayer, etc.get_package: Get full details for aowner/repocombination.get_stats: View global PawnDex metrics.get_languages: List supported languages in the index.
Related MCP server: conda-meta-mcp
Installation
Add the following to your claude_desktop_config.json:
{
"mcpServers": {
"pawndex": {
"command": "uv",
"args": [
"--directory",
"/path/to/pawndex_mcp_server",
"run",
"pawndex_mcp_server"
]
}
}
}Create a .mcp.json file in your project root:
{
"mcpServers": {
"pawndex": {
"command": "uv",
"args": [
"--directory",
"/path/to/pawndex_mcp_server",
"run",
"pawndex_mcp_server"
]
}
}
}Or add via CLI:
claude mcp add pawndex -- uv --directory /path/to/pawndex_mcp_server run pawndex_mcp_serverAdd to your opencode.jsonc:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"pawndex": {
"type": "local",
"command": [
"uv",
"--directory",
"/path/to/pawndex_mcp_server",
"run",
"pawndex_mcp_server"
],
"enabled": true
}
}
}Add to your .gemini/settings.json:
{
"mcpServers": {
"pawndex": {
"command": "uv",
"args": ["--directory", "/path/to/pawndex_mcp_server", "run", "pawndex_mcp_server"]
}
}
}Or add via CLI:
gemini mcp add pawndex -- uv --directory /path/to/pawndex_mcp_server run pawndex_mcp_serverAdd to your ~/.codex/config.toml or project-scoped .codex/config.toml:
[mcp_servers.pawndex]
command = "uv"
args = ["--directory", "/path/to/pawndex_mcp_server", "run", "pawndex_mcp_server"]Or add via CLI:
codex mcp add pawndex -- uv --directory /path/to/pawndex_mcp_server run pawndex_mcp_serverDevelopment
Requires Python 3.11+.
# Install dependencies
uv sync
# Run the server locally (STDIO)
uv run pawndex_mcp_serverLicense
MIT
Available Tools
4 toolsget_languagesA
Get the list of supported languages in PawnDex.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
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 only mentions 'Get the list' which implies a read operation, but it does not disclose behavioral traits such as read-only guarantee, authentication requirements, or whether the list is static/dynamic. This lack of transparency is a gap.
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 redundant information. It conveys the purpose clearly and efficiently, earning a high score for conciseness.
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 has no parameters and an output schema is present (which presumably describes return values), the description is complete. It covers the essential purpose without needing to explain return format or additional details. This is fully adequate for a simple getter.
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 does not need to add parameter information, and it correctly avoids doing so. No additional parameter semantics are required.
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 (get), the resource (list of supported languages), and the context (PawnDex). It is distinct from sibling tools like search_packages, get_package, and get_stats, so purpose clarity is high.
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 usage: an agent would use this tool when it needs the list of supported languages. However, it does not explicitly state when to use it versus alternatives or mention any exclusions. Since the resource is unique, it is minimally adequate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_packageA
Get detailed information about a specific Pawn package.
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | The repository name (e.g. 'samp-stdlib'). | |
| owner | Yes | The GitHub username or organization (e.g. 'pawn-lang'). |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden. It clearly indicates a read operation ('Get'), but provides no detail on potential side effects, authentication needs, or error behavior. For a simple getter, this is acceptable but not rich.
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 sentence with no filler. Every word contributes to conveying the tool's purpose, and it is front-loaded with the action verb.
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 is simple, has an output schema, and the schema covers all parameters. The description adequately conveys the core function, though slightly more context about the package source or the nature of 'detailed information' could have been provided. Overall, it is sufficiently complete for a getter.
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 already fully documents both parameters (owner and repo) with examples, achieving 100% schema description coverage. The description adds no additional parameter-level meaning, so the baseline score of 3 is appropriate.
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 uses the specific verb 'Get' with a clear resource 'detailed information about a specific Pawn package'. It distinguishes itself from sibling tools like search_packages, which searches, and get_stats/get_languages, which target other aspects.
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 usage when a specific package is known, but provides no explicit guidance on when to prefer this tool over siblings. The term 'specific' hints at the contrast with search_packages, but no direct exclusions or alternatives are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_statsB
Get global statistics for the PawnDex index.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavioral traits. It only states 'Get global statistics' with no mention of authentication requirements, rate limits, data freshness, or side effects. This is essentially the bare minimum expression of the operation.
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, direct sentence that front-loads the key information. It contains no filler, redundant phrasing, or unnecessary details, making it optimally concise and well-structured.
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, output schema exists, no nested objects), the description is largely sufficient. While it could mention what statistics are included (e.g., package count, language distribution), the output schema presumably covers return values. The context is complete for practical purposes.
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 accepts zero parameters, so the description does not need to add semantic meaning. According to the baseline rule for 0 parameters, a score of 4 is appropriate because there are no parameter details to elaborate on.
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's action ('Get'), resource ('global statistics'), and scope ('PawnDex index'). It distinguishes itself from siblings (search_packages, get_package, get_languages) by focusing on overall statistics rather than individual packages or languages.
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 no guidance on when to use this tool versus alternatives. It neither states explicit use cases, prerequisites, nor exclusions. The only implied usage is if a user needs global statistics, but there is no concrete context or comparison to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_packagesA
Search for Pawn packages on PawnDex.
| Name | Required | Description | Default |
|---|---|---|---|
| q | No | Search query (e.g. 'mysql', 'is:official', 'user:openmultiplayer', 'label:plugin'). | |
| page | No | Page number for pagination. | |
| sort | No | Field to sort by: 'stars', 'updated', or 'best'. | best |
| limit | No | Number of items to return (max 100). | |
| direction | No | Sort direction: 'asc' or 'desc'. | desc |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits, but it only states the basic action. It does not mention that it is a read-only search, that results are paginated, that query syntax supports filters like 'is:official', or any other behavioral details. The schema covers some of this, but the description itself is insufficient.
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 sentence, front-loaded with the verb and resource. There is zero wasted wording, and it is entirely to the point.
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 is simple, has an output schema, and the input schema fully documents parameters. However, the description lacks any behavioral context beyond the bare minimum, such as clarifying that it returns a list of packages or noting any limitations. It is minimally viable but not rich.
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 baseline is 3. The description adds no parameter-level information beyond what the schema already provides. It does not compensate or add extra context about parameters.
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 it searches for Pawn packages on PawnDex. It uses a specific verb ('search') and resource ('Pawn packages on PawnDex'), which distinctly separates it from sibling tools like get_package or get_stats.
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 usage context is implied (when you need to find packages), but there is no explicit guidance on when to use this tool versus alternatives such as get_package for known packages. No exclusions or alternative tool mentions are provided.
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. Dates show when Glama detected each change.
4 tool updates
v0.1.0- First observed
get_languages - First observed
get_package - First observed
get_stats - First observed
search_packages
TDQS
Each tool serves a distinct purpose: searching packages, retrieving package details, fetching global stats, and listing supported languages. There is no overlap or ambiguity between them.
All tool names follow a consistent verb_noun pattern (search_packages, get_package, get_stats, get_languages), making the API predictable and easy to navigate.
With 4 tools, the server is well-scoped for its purpose as a package index. Each tool is essential and the count is neither too sparse nor bloated.
The domain is a read-only package index, and the tools cover the core workflows: finding packages (search), examining details (get_package), and accessing supporting metadata (stats, languages). No obvious gaps exist.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Personal assistant MCP server with search, execute, packages, jobs, secrets, and integrations.
MCP server for hex.pm and hexdocs.pm: search, inspect, compare, and audit Elixir packages
- UnifAPIOAuthcom.unifapi
Hosted MCP server for live public-data APIs and Skills for AI agents.
Related MCP Servers
AlicenseAqualityCmaintenanceMCP server for the LPM package registry, enabling AI tools to search, browse source code, install packages, check quality, and more.1718ISC- AlicenseNot gradedqualityAmaintenanceAn MCP server that exposes authoritative, read-only Conda ecosystem metadata for AI agents, enabling package search, dependency resolution, and other packaging queries without side effects.6BSD 3-Clause
- AlicenseNot gradedqualityCmaintenanceMCP server for comprehensive PyPI package intelligence, providing tools for dependency analysis, security scanning, health scoring, license compliance, and trend tracking.MIT
- AlicenseAqualityDmaintenanceMCP server providing dependency and package management tools for AI agents. Analyze licenses, find outdated packages, visualize dependency trees, estimate bundle sizes, and audit security vulnerabilities.549MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/sittiev/pawndex_mcp_server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server