# Smithery MCP

> Smithery provides an MCP registry for discovering, managing, and connecting external AI services. It centralizes access control by handling OAuth and tokens automatically. Use it to let your agent find any compatible service—from Stripe or GitHub—and establish secure connections without manual credentials.

## Overview
- **Category:** friends-mcp
- **Price:** Free
- **Tags:** registry, api-management, discovery, oauth, analytics

## Description

Smithery handles the messy part of connecting your AI agent to outside services. You don't wanna write boilerplate OAuth code or deal with token expiration every time you build something new. Smithery acts as the centralized control plane, letting your agent find and connect to external MCP servers—whether that's Stripe, GitHub, or some niche database—without you needing to manage credentials manually.

**Discovering Services**

Need to know what services are out there? You use `search_servers` to scan the entire registry. You can filter results by a server's name, specific tags, or even keywords in its description field; it’ll spit back everything that matches your criteria. Once you narrow down what you need, you can check the core metadata of any registered service using `get_server_details`. This lets you confirm the current status and basic info before you commit to connecting.

**Inspecting Capabilities**

You gotta know exactly what a server *can* do before your agent tries it. Smithery gives you three main views: first, use `get_server_tools` to list every single function—or 'tool'—available on that server. This output includes the necessary input schemas and descriptions so your agent knows precisely which actions it can take; it’s like reading a full API contract for its capabilities. Second, if you wanna see what data is sitting there waiting to be read, `get_server_resources` returns all exposed data resources, giving you their names and MIME types. Finally, check out the built-in workflows: `get_server_prompts` lists reusable prompt templates available on a server, which gives your agent pre-defined ways to structure its requests.

**Managing Connections and Credentials**

Connecting is where Smithery saves your bacon. Instead of handling complex OAuth handshakes yourself, you use `create_connection`. This tool handles the entire authentication and session complexity automatically for your application. Once that’s done, it gives you a managed connection to use. Need to audit what's hooked up? Run `list_connections` to get a full list of every existing connection within a specific namespace. You can also check the status or review details of any single, established link using `get_connection`. If that service relationship breaks down or you need to cut ties completely, use `delete_connection`; this removes the server connection from the registry and revokes access immediately, but remember, this action is final.

**Security and Monitoring**

For security, don't just hand out your main API key. Use `create_service_token` to generate a secure, time-limited token that has restricted permissions. This keeps the blast radius small for any frontends or agents you deploy. When things get complex and you need to know if a service is performing right, run `get_server_analytics`. This pulls usage metrics and adoption data for a named server, helping you spot trends and figure out where performance issues are kicking off. The whole process means your agent doesn't need specialized knowledge of every vendor’s API; it just needs to ask Smithery where the data or service is located.

## Tools

### create_connection
Creates a managed connection to an MCP server, handling all OAuth and session complexity automatically for your application.

### create_service_token
Generates a secure, time-limited token with restricted permissions for frontends or agents that shouldn't use your main API key.

### delete_connection
Removes an MCP server connection from the registry; this action revokes access and cannot be undone.

### get_connection
Retrieves detailed status information about a specific, existing MCP connection for review or debugging purposes.

### get_server_analytics
Fetches usage metrics and adoption data for a named MCP server to help you monitor performance and identify trends.

### get_server_details
Retrieves core metadata about an MCP server from the registry, letting you check its status before connecting it.

### get_server_prompts
Lists reusable prompt templates available on a server, giving you insight into pre-defined workflows for your agent.

### get_server_resources
Returns all data resources exposed by the server, including their names and MIME types, so you know what data is readable.

### get_server_tools
Lists every function (tool) available on a server, providing input schemas and descriptions so your agent knows what actions it can take.

### list_connections
Returns a list of all existing connections within a namespace, allowing you to audit which services are currently linked up.

### search_servers
Searches the entire Smithery registry for MCP servers using name, tags, or description filters to find what you need.

## Prompt Examples

**Prompt:** 
```
Search for verified GitHub-related MCP servers
```

**Response:** 
```
I'll search the Smithery registry for verified GitHub MCP servers.
```

**Prompt:** 
```
Show me all tools exposed by the Stripe MCP server
```

**Response:** 
```
I'll retrieve the complete tool catalog from the Stripe MCP server.
```

**Prompt:** 
```
Create a connection to the Slack MCP server for my workspace
```

**Response:** 
```
I'll create a managed connection to the Slack MCP server through Smithery Connect.
```

## Capabilities

### Discover Servers
Search and retrieve detailed metadata about any registered MCP server using `search_servers`.

### Inspect Server Capabilities
List every available tool, data resource, or prompt template exposed by a specific server using dedicated getter tools (e.g., `get_server_tools`).

### Manage Connections
Establish and revoke secure connections to external MCP services using `create_connection` and `delete_connection`.

### Generate Access Tokens
Create short-lived, scoped service tokens (`create_service_token`) that limit access permissions for specific frontends or agents.

### Audit Usage Metrics
Monitor adoption rates and performance issues by retrieving usage analytics for a server using `get_server_analytics`.

## Use Cases

### Need to connect a new niche API
A developer needs to use a brand-new accounting service (AcmeCorp). Instead of manually reading AcmeCorp's OAuth docs and integrating the flow, they simply run `search_servers` for 'AcmeCorp', then call `get_server_details` to confirm it’s ready. The agent then uses `create_connection`, and suddenly, the API is available in their code with zero credential headache.

### Debugging a flaky service integration
The agent reports an error on a connection. Instead of blindly checking logs, the architect calls `get_server_analytics` for that specific service. The analytics show a sudden spike in failures around 3 AM UTC, pointing to a rate limit issue. They then use `get_connection` to review the current usage limits and fix the scope.

### Building a secure multi-client dashboard
A platform needs to let three different teams access Stripe, GitHub, and Jira data simultaneously but with varying permissions. Instead of creating three separate credential vaults, they use `create_service_token` for each team's specific scope (e.g., 'read: billing' vs 'write: tickets'), keeping the main API key safe.

### Onboarding a new developer to the platform
A junior dev needs to understand all available data sources for a project. They use `search_servers` with broad tags like 'finance'. The agent then systematically calls `get_server_resources` and `get_server_tools` on each result, creating an instant, comprehensive inventory map without the developer having to read dozens of docs.

## Benefits

- Forget manual OAuth. Use `create_connection` to establish secure links in one go. Smithery handles the token flow and session management automatically, so you never deal with expired secrets again.
- Stop guessing what a server can do. Calling `get_server_tools` gives your agent an immediate catalog of every available function, letting it build complex multi-step actions right out of the gate.
- Audit everything easily. The `list_connections` tool lets you see all active connections across namespaces. This is critical for compliance and finding those forgotten dev environments.
- Stay secure with limited tokens. Instead of exposing your main API key, use `create_service_token`. You define the exact scope (read-only, specific resources) needed, minimizing risk.
- Understand adoption rates. Use `get_server_analytics` to track which services are actually getting used. This data helps justify migration efforts or resource scaling.

## How It Works

The bottom line is you use natural language commands to let your agent handle all discovery, authentication, and management overhead.

1. Your AI agent uses the `search_servers` tool to find the desired service (e.g., 'Stripe') and gets its qualified name.
2. The agent then calls `get_server_tools` using that name to verify exactly what actions are available, then executes `create_connection` to manage authentication.
3. Finally, your application uses the connection ID provided by Smithery to run the service's functions without managing any OAuth details.

## Frequently Asked Questions

**How do I find available MCP servers using Smithery?**
You use the `search_servers` tool. You can filter by name, tags, or description to narrow down results and get a list of qualified names for services you want to connect.

**Can I test an MCP server before making a live connection using Smithery?**
Yes. Before calling `create_connection`, use `get_server_details` to review the metadata and confirm the server's status. You can also run `get_server_tools` to see its capabilities first.

**What is the difference between `list_connections` and `get_connection` in Smithery?**
`list_connections` gives you a list of all connection IDs and names across your namespace for an audit. You use `get_connection` when you want full details—like creation dates or specific metadata—for one particular ID.

**Does Smithery help with security tokens?**
Absolutely. Use the `create_service_token` tool to generate limited-scope, time-bound tokens. This prevents your agent from using a master key and greatly reduces the risk if credentials leak.

**When I call `get_server_analytics`, what kind of performance data or rate limits can I monitor?**
The analytics report tracks usage volume, adoption trends, and overall server health. While it shows throughput metrics, remember that your client needs to handle any specific API rate limit errors.

**What information do I get from `get_server_tools` regarding input data schemas?**
It returns the tool name, description, and detailed input schema for every function. This lets you build calls that match the server's required parameters exactly.

**If I have connectivity issues, how does `get_connection` help me troubleshoot?**
It provides the current status, connection ID, and metadata for a specific link. This helps you confirm if the connection is active or review configuration details when things break.

**How granular can I make permissions when using `create_service_token`?**
You define highly scoped tokens based on policy. You control access by specifying namespaces, resources, operations, and the token's expiration time (TTL).

**Do I need a Smithery account to use this MCP server?**
Yes, you need a free Smithery account to generate an API key. Sign up at smithery.ai, then go to Account Settings > API Keys to create your key. The key gives access to the registry search, server details, and connection management features.

**How does Smithery Connect handle OAuth for MCP servers?**
Smithery Connect automatically handles OAuth flows, token refresh, and session management for MCP servers that require authentication. You don't need to configure redirect URIs, client IDs, or manage token expiration. Simply create a connection and Smithery manages the authentication lifecycle, providing your agents with seamless access.

**Can I search for verified MCP servers only?**
Yes! Use the verified filter in the search_servers tool by setting verified=true. This returns only servers that have been verified by Smithery, ensuring higher quality and security standards. Verified servers display a verification badge and have undergone additional review.