# Glama MCP

> Glama MCP acts as a unified intelligence gateway for your AI client. It lets you dynamically discover external Model Context Protocols (MCPs), inspect their parameters, and route conversational prompts to multiple LLM networks without leaving your core workflow. You use it when you need deep visibility into an array of remote AI services.

## Overview
- **Category:** friends-mcp
- **Price:** Free
- **Tags:** llm-gateway, model-registry, api-proxy, mcp-discovery, ai-infrastructure

## Description

Finding the right model or service context shouldn't feel like archaeological digging through a developer dashboard. This MCP lets your agent search across global directories, finding compatible protocols on demand. Instead of logging into five different platforms to check model compatibility or parameters, you ask this MCP, and it handles the connection mapping for you. It consolidates complex programmatic text completion by routing requests through its gateway proxy. You can also examine detailed metadata about any given protocol using Vinkius's central catalog, making sure your local logic connects cleanly to external services. This capability means your agent isn't limited by what's installed locally; it accesses a network of capabilities.

## Tools

### glama_get_gateway_model_details
Checks specific settings for a proxied AI model, like its price or context window size.

### glama_get_gateway_models
Provides a complete list of all available AI models supported through the Glama gateway.

### glama_list_mcp_servers
Searches and lists available MCP protocols across the entire global directory using simple text matching.

### glama_run_gateway_chat
Starts a conversation prompt with an isolated model via the gateway proxy network.

### glama_get_hosted_instances
Fetches a list of private MCP instances assigned only to your specific account.

### glama_get_mcp_attributes
Lists the standard classification strings and filtering attributes mapped within the global MCP registry.

### glama_get_mcp_server_info
Extracts detailed parameters and setup instructions for a single, specific MCP server by its name.

### glama_send_telemetry
Reports usage metrics and execution data back to the Glama telemetry system after a tool runs.

## Prompt Examples

**Prompt:** 
```
Find all MCP servers relating to CRM logic inside the registry, then let me know their basic descriptions.
```

**Response:** 
```
Querying global scopes (`glama_list_mcp_servers`)... I found Salesforce-MCP and HubSpot-MCP. Their parameters indicate robust handling for dynamic B2B data contexts via local interfaces locally.
```

**Prompt:** 
```
Are there smaller LLMs available on the Glama API gateway we can proxy text to quickly?
```

**Response:** 
```
Retrieving standard OpenAI-compatible definitions (`glama_get_gateway_models`)... Several smaller proxies are available. Meta Llama 3 8B and Claude 3 Haiku both demonstrate operational speeds with low logical barriers ready for semantic requests.
```

**Prompt:** 
```
Report a successful telemetry execution map event back to Glama for the GitHub repo tool.
```

**Response:** 
```
Initiating logging sequences via `glama_send_telemetry`. Tool usage event for 'github_repo' logged with success status. Your action matrix is appropriately registered within the global metrics securely.
```

## Capabilities

### Find available protocols
List and search the entire global directory of compatible MCPs using loose text matching.

### Check model details
Get specific configurations, including prices and context window sizes, for any proxied AI gateway model.

### Run conversations remotely
Send a chat prompt to an isolated, specified LLM network without keeping the conversation in your local memory.

### Track usage metrics
Report execution and usage data back to the Glama backend after an AI tool finishes running.

### Audit hosted resources
Fetch a list of private MCP instances assigned specifically to your account for access control checks.

## Use Cases

### Need to compare three different external knowledge bases?
You need to test how your agent handles data from a CRM, an ERP system, and a niche industry database. Your agent can query the global directory using `glama_list_mcp_servers` to find all necessary protocols, then run prompts through `glama_run_gateway_chat` for side-by-side comparison.

### Building a robust multi-stage agent workflow?
Your agent must first check the status of local resources and then query an external model. It can use `glama_get_hosted_instances` to validate internal access before sending data out via `glama_run_gateway_chat`.

### Tracking costs across different AI models?
You need to know if using a small, fast LLM is cheaper than using the high-context model. You use `glama_get_gateway_model_details` first to confirm prices and window sizes before running any prompts.

### After a complex data extraction job?
The agent successfully retrieves sensitive financial data from an external source. It uses `glama_send_telemetry` immediately afterward to report the successful execution metrics back to the Glama backend for auditing.

## Benefits

- You can find protocols quickly. Instead of guessing, use `glama_list_mcp_servers` to search the global directory for exactly what you need.
- Test models without switching clients. Use `glama_run_gateway_chat` to send a conversation prompt to an isolated model through the proxy network.
- Know your limits upfront. Before connecting, check model details using `glama_get_gateway_model_details` to confirm context window sizes and pricing.
- Manage resources centrally. Use `glama_get_hosted_instances` to view all private MCP instances assigned to your account in one place.
- Audit the system. Run `glama_get_mcp_attributes` to find out what standard classifications are mapped across global protocols.

## How It Works

The bottom line is, this MCP provides a centralized hub for finding and routing requests to any external AI service you need.

1. First, use the `glama_list_mcp_servers` tool to search the global directory and pinpoint the exact protocols you need.
2. Next, if you want to run a chat or test a model, specify the target model's details and send your prompt using `glama_run_gateway_chat`.
3. Finally, after the process is done, use `glama_send_telemetry` to log the successful execution metrics back to Glama.

## Frequently Asked Questions

**How do I use glama_list_mcp_servers to find a new industry protocol?**
Use this tool by providing keywords related to the desired domain. The MCP will search its global directory and return any protocols that match your criteria, helping you locate niche services quickly.

**What is the difference between glama_get_gateway_models and glama_list_mcp_servers?**
`glama_get_gateway_models` lists all general AI models available via the proxy. `glama_list_mcp_servers` searches for specific, specialized protocols across different MCP domains.

**Can I use glama_run_gateway_chat to test a model before committing?**
Yes. You can send an isolated conversational prompt using `glama_run_gateway_chat`. This lets you test the model's performance and tone without having that conversation permanently stored in your local system.

**If I run a process, how do I track it?**
After any tool execution, always use `glama_send_telemetry`. This sends the usage metrics back to Glama, giving you an auditable record of what happened and for how long.

**How does using glama_get_hosted_instances help me manage private data security?**
It fetches only the MCP instances assigned to your specific account. This function keeps your private, hosted protocols separate from the public registry view.

**If I get an error calling glama_get_mcp_server_info, what should I check first?**
You need to verify that you have the correct namespace and slug for the MCP. The function requires these two unique identifiers to extract detailed parameters.

**What determines if an MCP is compatible with my local system? Can glama_get_mcp_attributes help?**
Yes, it lists filtering attributes and semantic categorizations mapped within the registry. These attributes allow you to assess a global protocol's compatibility requirements before connecting.

**What specific technical parameters can I check using glama_get_gateway_model_details?**
The tool provides granular model information, including pricing details, the exact context window size, and operational parameters for a specific proxied gateway model.

**Can I test alternative AI models entirely within the terminal using the Glama integration?**
Yes. Tools like `glama_get_gateway_models` list available OpenAI-compatible proxies, and `glama_run_gateway_chat` allows your Vinkius agent to run text completions outside itself natively.

**Does the Glama server provide telemetry data back to the registry?**
Yes. Active MCP usage events can be logged seamlessly applying the `glama_send_telemetry` tool in specific sequences to inform publishers about proxy executions.

**Are private hosted instances queryable?**
Yes. By executing `glama_get_hosted_instances`, your agent limits queries exclusively to private proxies explicitly belonging to your linked environment.