# Glama MCP for AI Agents AI Agent Connect

> Glama connects your AI agent to the Glama directory. It lets you discover Connectors dynamically, analyze model attributes, and proxy external intelligence networks through a unified gateway. It's built for anyone who needs to manage complex AI workflows without the headache of multiple APIs.

## Overview
- **Category:** friends-mcp
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_3I3xkcQ0Lir2EbUp0HqzccT0Pcn6Iy0qjp9A5LCu/ai-agent-connect
- **Tags:** llm-gateway, model-registry, api-proxy, mcp-discovery, ai-infrastructure

## Description

The Glama MCP provides a bridge to the Glama infrastructure for discovery and model routing. Instead of jumping between different web interfaces to find compatible tools, you can let your agent search and inspect the registry on the fly. It gives your agent the ability to see what's available, check specific details like context windows or pricing, and then execute prompts through a unified gateway. This is a huge win for building systems that need to scale because it handles the messy parts of multi-model logic for you. You can route requests to different providers without rewriting your core logic every time you want to try a new model. It's a solid way to manage your AI's capabilities while keeping your own code clean and focused on the actual work. If you're using Vinkius to manage your tools, this is the bridge that lets your agent actually interact with the wider world of AI models and protocols without you having to babysit the connections. It makes the whole process of building and maintaining an agentic workflow much simpler. For instance, if you need to swap from one model to another for a specific task, you don't have to update your environment variables or swap out keys. You just tell your agent to use the gateway to find the best fit. This turns a complex infrastructure problem into a simple, programmable request.

## Tools

### glama_get_hosted_instances
Access the private hosted MCP instances tied to your specific account. This keeps your internal tools secure and reachable.

### glama_get_mcp_attributes
See the categories and filtering tags used in the Glama registry. Use this to narrow down your search for specific types of tools.

### glama_get_mcp_server_info
Pull the exact parameters and setup steps for a specific MCP. This makes it easy to get a new tool running quickly.

### glama_send_telemetry
Send usage data and execution metrics back to the Glama backend. Use this to monitor your agent's performance and costs.

### glama_get_gateway_model_details
Get specific details like pricing and context windows for models in the Glama gateway. This helps you plan your costs and limits before running a task.

### glama_get_gateway_models
See every AI model currently supported by the Glama gateway. Use this to audit your available model options in one list.

### glama_list_mcp_servers
Search the global directory to find new Connectors for your agent. This helps you discover new capabilities without manual searching.

### glama_run_gateway_chat
Send a prompt to a specific model through the Glama proxy network. This lets you swap models instantly without changing your code.

## Prompt Examples

**Prompt:** 
```
How can I find tools for managing my CRM?
```

**Response:** 
```
I've searched the directory and found a few options for CRM logic. Here are the best matches:

- **Salesforce-MCP**
- **HubSpot-MCP**
- **Zoho CRM**

These all support dynamic data handling and can be integrated into your current workflow.
```

**Prompt:** 
```
What models are available on the gateway and what are their limits?
```

**Response:** 
```
Here are the models currently available through the Glama gateway:

| Model | Context Window | Pricing |
| --- | --- | --- |
| Claude 3.5 Sonnet | 200k | Standard |
| Llama 3 8B | 8k | Low Cost |
| Haiku | 32k | Very Low Cost |

You can route your prompts to any of these based on your needs.
```

**Prompt:** 
```
How do I see the setup info for a specific MCP?
```

**Response:** 
```
To get the setup details for a specific MCP, I'll need the name or slug. Once you provide that, I can pull the exact installation steps and configuration parameters for you.
```

## Capabilities

### Search the global MCP directory
Use Glama to find new Connectors for your agent from a central registry.

### Query specific model configurations
Use Glama to check pricing, context windows, and other parameters for any model in the gateway.

### Route prompts through a unified gateway
Use Glama to send prompts to different models through a single proxy network.

### Fetch private hosted MCP instances
Use Glama to access private Connectors tied to your specific account.

### Retrieve detailed installation instructions
Use Glama to pull specific setup parameters and requirements for any Connector in the registry.

### Report usage metrics to a telemetry backend
Use Glama to send execution data and performance metrics back to the infrastructure.

## Use Cases

### Finding CRM tools for a new workflow
An analyst wants to find a CRM integration. The agent uses glama_list_mcp_servers to find relevant tools and then pulls the info to start the project.

### Checking model limits before a long task
A developer wants to see if a model can handle a large file. The agent uses glama_get_gateway_model_details to check context windows first.

### Routing prompts to the best model
An app needs to run a complex reasoning task. The agent uses glama_run_gateway_chat to send the request to the best model for the job.

### Accessing a private internal tool
A team needs to use a secret tool for internal data. The agent uses glama_get_hosted_instances to find and run it securely.

## Benefits

- Stop hunting for Connectors manually. Use glama_list_mcp_servers to find exactly what you need in seconds.
- Switch models without changing code. Use glama_run_gateway_chat to route requests to different providers instantly.
- Understand your costs and limits. Use glama_get_gateway_model_details to see context windows and pricing before you run a task.
- Manage private tools easily. Use glama_get_hosted_instances to keep your internal Connectors secure and accessible.
- Get clear setup instructions. Use glama_get_mcp_server_info to see exactly how to configure a new tool.
- Track your agent's performance. Use glama_send_telemetry to monitor how your tools are performing in the wild.

## How It Works

The bottom line is you get a single point of entry for your entire AI infrastructure.

1. Grab your API key from the Glama dashboard.
2. Add the GLAMA_API_KEY to your environment variables.
3. Ask your agent to find or run tasks using the Glama tools.

## Frequently Asked Questions

**What is the Glama MCP?**
The Glama MCP is a bridge that connects your AI agent to a large directory of tools and a unified gateway for various AI models.

**Can I use multiple models with Glama?**
Yes, you can route prompts to different models through the Glama gateway without having to manage separate API keys for each one.

**How do I find new tools for my AI agent?**
You can search the global registry directly using the Glama MCP to see what tools are available and what they do.

**Can I keep my private Connectors secure?**
Yes, the Glama MCP allows you to fetch and use private hosted instances that are tied specifically to your account.

**How do I see model pricing with Glama?**
You can query the gateway to see specific details like pricing and context windows for any model before you run your tasks.

**Can I track my agent's usage?**
Yes, the Glama MCP includes tools to send telemetry and execution metrics back to the backend so you can monitor performance.

**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.