### Automated OpenAPI Mapping

HasMCP's **Automated OpenAPI Mapping** feature is a core component that streamlines the process of making existing APIs available to Large Language Models (LLMs). Here's a breakdown of what that means:

- **What it does:** It takes your existing API documentation, specifically OpenAPI (version 3.0 or 3.1) or Swagger files, and automatically translates them into a format that LLMs can understand and use. This format is called the Model Context Protocol (MCP).
- **Why it's important:** Normally, connecting an LLM to an API requires a developer to write a significant amount of "glue code" to handle things like authentication, data formatting, and error handling. HasMCP automates this, saving significant time and effort.
- **How it works:** HasMCP analyzes your OpenAPI specification to understand the available endpoints, the required parameters, and the structure of the data that is sent and received. It then generates the necessary MCP "tool" definitions. This allows an LLM, like Gemini, to see your API as a tool it can use to perform tasks.
- **Key benefits:**
  - **Speed:** Go from an OpenAPI file to an LLM-callable tool in seconds.
  - **Accuracy:** By using the formal OpenAPI definition, the chance of errors in the integration is significantly reduced.
  - **No-Code:** You don't need to write any server-side code to make your API available to an LLM.

In essence, Automated OpenAPI Mapping acts as a bridge, allowing you to quickly and easily connect your existing APIs to the world of generative AI without being a burden on your engineering team. This automated translation ensures that every endpoint is correctly typed and documented for the LLM to use with high confidence.

### Native MCP Elicitation Auth

This feature is about solving the complex problem of authentication when an LLM needs to use an API on your behalf. Here's a deeper dive:

- **What it is:** "Elicitation" is a fancy word for "asking for." In the context of MCP, it's a secure way for the system to pause and ask the user for information. "Native MCP Elicitation Auth" means that HasMCP has built-in support for using this "asking" mechanism to handle authentication, specifically with OAuth2.
- **Why it's important:** You can't just give an LLM your username and password. That would be a huge security risk. Instead, modern applications use protocols like OAuth2, where you are redirected to a trusted website (like Google or your corporate login page) to sign in. HasMCP's Elicitation Auth manages this process.
- **How it works:**
  1.  The LLM decides it needs to use a tool that requires you to be logged in.
  2.  HasMCP, acting as the MCP server, detects this and initiates the OAuth2 flow.
  3.  It then "elicits" your permission by providing a secure URL. You, the user, would then click this link, which takes you to the standard login page.
  4.  After you successfully log in, the authentication service sends a secure token back to HasMCP.
  5.  HasMCP can then use this token to make API calls on your behalf.
- **Key benefits:**
  - **Security:** Your credentials are never exposed to the LLM or stored in an insecure way. The process follows industry-standard security protocols.
  - **User Experience:** You get the familiar "Log in with..." experience you're used to in other applications.
  - **Automation:** The process is handled automatically by HasMCP, so developers don't have to build this complex authentication logic themselves.

In short, Native MCP Elicitation Auth is a secure and user-friendly way to handle API authentication in an LLM-powered world, and HasMCP has this capability built-in from the ground up. By handling the entire OAuth2 lifecycle—from consent to token refresh—HasMCP ensures that your agents always have the authorization they need to act on your behalf.

### MCP Resource & Prompt Support

This feature extends HasMCP's capabilities to support the full Model Context Protocol specification, enabling deeper context and more consistent model behavior.

- **What it is:** MCP is a comprehensive protocol that defines more than just "Tools" (functions). It also includes "Resources" (standardized data access) and "Prompts" (shared instruction templates).
- **Why it's important:** LLMs often need access to static or dynamic data (like documentation, logs, or database snapshots) that doesn't fit the "tool" pattern. They also benefit from centrally managed prompts to ensure consistent personality and logic across different environments.
- **How it works:** 
  - **Resources:** HasMCP exposes files, API responses, and database views as "Resources" with unique URIs. LLMs can browse and "read" these resources to gain deep situational awareness.
  - **Prompts:** HasMCP allows you to define and version-control prompt templates. These can be used to prime an LLM for a specific task or persona, ensuring that everyone in your organization gets the same high-quality AI experience.
- **Key benefits:**
  - **Context-Rich AI:** Provide agents with multi-megabyte data sets via resources without overwhelming the tool definition space.
  - **Uniform Behavior:** Maintain consistent "System Instructions" and "Few-Shot Examples" across all your AI agents.
  - **Standardized Interoperability:** Fully compatible with any MCP client, maximizing the value of your existing data sources.

### Context Window Optimization

This feature is all about making your interactions with LLMs faster and cheaper. It addresses a fundamental challenge with how LLMs work:

- **What it is:** The "context window" is the amount of information an LLM can "remember" at any given time. Everything you say to it, and everything it says back, goes into this window. Larger context windows are powerful but also more expensive and slower to process. HasMCP's **Context Window Optimization** is a set of tools to reduce the amount of unnecessary data that goes into this window.
- **Why it's important:** When an LLM calls an API, the API might return a lot of data that isn't relevant to the immediate task. Sending all of this data to the LLM is wasteful. It increases the cost of the LLM interaction (since you're paying per token) and it can slow down the response time.
- **How it works:** HasMCP provides two primary ways to optimize the context window:
  1.  **JMESPath Pruning:** JMESPath is a query language for JSON. It allows you to specify exactly which parts of a JSON response you want to extract. For example, if an API returns a large user object, you could use a JMESPath expression to pull out just the user's name and email address, and discard the rest. This is a very fast and efficient way to filter data.
  2.  **Goja (JS) Logic:** For more complex situations, HasMCP includes the Goja engine, which allows you to write JavaScript code to process the API response. This gives you the full power of a programming language to manipulate the data before it's sent to the LLM. You could, for example, combine multiple fields, format dates, or perform other transformations.
- **Key benefits:**
  - **Cost Savings:** By reducing the number of tokens sent to the LLM, you can significantly lower your API costs.
  - **Improved Performance:** Smaller amounts of data can be processed more quickly, leading to faster response times from the LLM.
  - **Increased Relevance:** By only sending the most relevant data, you can help the LLM focus on what's important and provide more accurate responses.

In summary, Context Window Optimization is a critical feature for building efficient and cost-effective LLM-powered applications, and HasMCP provides powerful tools to achieve this. By minimizing the "noise" sent to the model, you not only save on costs but also significantly improve the model's ability to focus on the most relevant information.

### Real-time Dynamic Tooling

This feature addresses the need for agility and responsiveness in an AI-powered ecosystem. It's about ensuring that the LLM always has an up-to-date understanding of the tools available to it.

- **What it is:** **Real-time Dynamic Tooling** is a capability of the Model Context Protocol (MCP) that allows the list of available tools to change on the fly, without requiring a server restart or manual intervention. HasMCP supports this through the `tool_changed` event.
- **Why it's important:** In a real-world environment, the tools available to an LLM are not static.
  - An API might be temporarily down for maintenance.
  - A new API might be deployed.
  - A user's permissions might change, giving them access to new tools or revoking access to old ones.
  - The structure of an API might change, with new parameters or different return values.
- **How it works:**
  1.  HasMCP continuously monitors the health and status of the APIs it's connected to.
  2.  If it detects a change (e.g., an API goes offline, a new one comes online, or a user's authentication status changes), it sends a `tool_changed` event to the LLM.
  3.  The LLM then knows that it needs to refresh its list of available tools.
  4.  This ensures that the LLM is always working with the most current information.
- **Key benefits:**
  - **Agility:** Your AI agents can adapt to changes in the environment in real-time.
  - **Resilience:** If a tool becomes unavailable, the LLM will know not to use it, preventing errors.
  - **Scalability:** New tools can be added to the system without any downtime.
  - **Security:** If a user's permissions are revoked, their access to tools is immediately cut off.

In essence, Real-time Dynamic Tooling brings a level of dynamism and robustness to LLM-powered applications that is essential for building real-world, production-ready systems. It ensures that your AI agents are always aware of their current environment, including changes in network status or backend API availability.

### Git Connections

Git Connections brings a GitOps workflow to the Model Context Protocol, allowing you to manage your AI tools with the same rigor as your production code.

- **What it is:** A native integration with GitHub and GitLab that automatically discovers, versions, and deploys MCP tool definitions directly from your source control repositories.
- **Why it's important:** As your AI stack grows, manual tool registry updates become a bottleneck. Versioning tool definitions is essential for auditability and reliability in production environments.
- **How it works:** Link your GitHub/GitLab organizations to HasMCP. The platform scans your selected repositories for MCP configuration files. Changes pushed to your main branch are tracked and automatically synced to HasMCP, keeping your production agents up-to-date instantly.
- **Key benefits:**
  - **Change Tracking:** Track every single change over Git source control—knowing exactly who updated which tool definition and when.
  - **Automated Deployment:** Push to Git to immediately update the capabilities of your LLM agents without manual intervention.
  - **Versioned Reliability:** Easily roll back to a previous tool version if a logic change in Git causes unexpected AI behavior.

### Secure Secret & Proxy Management

This feature is about ensuring that your sensitive information, like API keys, is handled in a secure and robust way.

- **What it is:** **Secure Secret & Proxy Management** refers to the capabilities within HasMCP for securely storing and using "secrets" (like API keys, database passwords, etc.) and for managing how data is proxied to and from your APIs.
- **Why it's important:**
  - **Security:** You should never hard-code secrets into your applications or expose them to the LLM. This would make them vulnerable to theft.
  - **Centralization:** In a large organization, you might have many different APIs, each with its own set of secrets. Managing these in a centralized way is more efficient and secure.
  - **Flexibility:** You might need to add or modify headers (like authentication tokens or tracking IDs) as requests are proxied to your backend services.
- **How it works:**
  - **Secrets Management:** HasMCP provides an "encrypted vault" for storing your secrets. This is a secure, centralized location where you can manage all of your sensitive information. When a request is made to an API, HasMCP automatically retrieves the necessary secrets from the vault and injects them into the request. The secrets are never exposed to the LLM or the end-user.
  - **Proxy Management:** HasMCP acts as a proxy between the LLM and your APIs. This allows it to intercept requests and responses and modify them as needed. For example, you can configure HasMCP to add a specific header to all requests that are sent to a particular API.
- **Key benefits:**
  - **Enhanced Security:** Your secrets are stored in a secure, encrypted vault and are never exposed to the LLM.
  - **Simplified Management:** You can manage all of your secrets in a single, centralized location.
  - **Increased Flexibility:** You have fine-grained control over how requests and responses are proxied to and from your APIs.

In summary, Secure Secret & Proxy Management is a critical feature for building secure, scalable, and manageable LLM-powered applications, and HasMCP provides a robust set of tools for this purpose.

### MCP Composition

This feature is about building highly performant and modular AI systems. It combines two powerful technologies: MCP Composition.

- **What it is:**
  - **MCP Composition:** The ability to chain multiple MCP servers together to create more complex and powerful tools.
- **Why it's important:**
  - **Modularity:** MCP Composition allows you to build complex AI systems from smaller, reusable components. This makes your system more flexible, scalable, and easier to maintain.
- **How it works:**
  - **MCP Composition:** HasMCP will allow you to define dependencies between MCP servers. For example, you could have one MCP server that provides weather data, and another that provides restaurant recommendations. You could then compose these two servers to create a new tool that recommends restaurants with outdoor seating on sunny days.
- **Key benefits:**
  - **Scalability:** Build complex systems from smaller, reusable components.
  - **Flexibility:** Easily create new tools and workflows by composing existing MCP servers.

In essence, gRPC & MCP Composition is about building the next generation of AI-powered applications: high-performance, modular, and scalable.

### JMESPath Pruning

This feature is a key part of HasMCP's **Context Window Optimization**. It's a powerful tool for reducing the amount of data that gets sent to the LLM, which in turn saves you money and makes your application faster.

- **What it is:**
  - **JMESPath:** A query language specifically designed for JSON. Think of it like SQL, but for JSON data.
  - **Pruning:** The process of cutting away unnecessary parts of the data.
  - **JMESPath Pruning in HasMCP:** HasMCP uses JMESPath to allow you to declaratively filter and reshape JSON responses from your APIs before they are sent to the LLM.
- **Why it's important:** APIs often return much more data than is actually needed for a specific task. For example, an API might return a user object with 50 fields, but you only need the user's name and email address. Sending all 50 fields to the LLM is wasteful.
- **How it works:** With HasMCP, you can define a JMESPath query that will be applied to the JSON response from your API. This query specifies exactly which fields to keep and which to discard. The "pruning" happens automatically before the data is passed to the LLM.
- **Key benefits:**
  - **Declarative and Simple:** JMESPath provides a simple, declarative way to specify the data you need. You don't have to write any procedural code.
  - **Efficient:** JMESPath is highly optimized for JSON data, so the pruning process is very fast.
  - **Reduces "Noise":** By removing irrelevant data, you can help the LLM focus on the information that is most important for the task at hand.

In short, JMESPath Pruning is a powerful and efficient way to optimize the data that you send to LLMs, and it's a core feature of HasMCP.

### Goja (JS) Logic

This feature is another key part of HasMCP's **Context Window Optimization**, offering a more powerful and flexible way to manipulate data than JMESPath Pruning.

- **What it is:**
  - **Goja:** An engine that allows you to run JavaScript code within a Go application.
  - **Goja (JS) Logic in HasMCP:** HasMCP embeds the Goja engine, allowing you to write "JavaScript Interceptors." These are snippets of JavaScript code that can intercept and modify the responses from your APIs before they are sent to the LLM.
- **Why it's important:** Sometimes, simple filtering with JMESPath isn't enough. You might need to perform more complex transformations on the data, such as:
  - Combining multiple fields into a single, more descriptive field.
  - Formatting dates or numbers.
  - Applying conditional logic (e.g., if a field has a certain value, then modify another field).
  - Enriching the data with information from other sources.
- **How it works:** In HasMCP, you can write a JavaScript function that will be executed on the JSON response from your API. This function has access to the full JSON object, and it can return a new, modified JSON object. This new object is then what gets sent to the LLM.
- **Key benefits:**
  - **Flexibility:** The full power of JavaScript is at your disposal, allowing you to perform almost any data transformation you can imagine.
  - **Procedural Logic:** Unlike the declarative nature of JMESPath, JavaScript allows you to write procedural code, with loops, conditionals, and other control structures.
  - **Stateful Transformations:** You can perform more complex, stateful transformations that are not possible with a simple filtering language.

In conclusion, Goja (JS) Logic is a powerful feature for advanced data manipulation. It complements JMESPath Pruning by providing a way to handle more complex scenarios, giving you complete control over the data that is sent to your LLM.

### Observability & Telemetry

This set of features is about giving you visibility into what your AI agents are doing. It's crucial for debugging, monitoring, and understanding how your tools are being used.

- **What it is:** **Observability & Telemetry** is a collection of tools within HasMCP that provide insights into the performance, usage, and security of your MCP servers.
- **Why it's important:** When you have LLMs calling your APIs, it can be difficult to understand what's happening "under the hood." Good observability tools are essential for:
  - **Debugging:** When something goes wrong, you need to be able to trace the flow of requests and responses to identify the source of the problem.
  - **Performance Monitoring:** You need to be able to monitor the latency and error rates of your tool calls to ensure that your application is performing well.
  - **Usage Tracking:** You need to be able to track who is using your tools and how often, which is important for billing and for understanding which tools are most valuable.
  - **Security Auditing:** You need to be able to monitor for suspicious activity and ensure that your security policies are being enforced.

Here's a breakdown of the specific observability features offered by HasMCP:

- **Tool Call Analytics:** This feature allows you to see which of your tools are being used most frequently. This can help you identify your most valuable tools and prioritize future development efforts.
- **User Governance:** This feature allows you to track tool usage on a per-user basis. This is essential for billing and for auditing tool usage across different users and departments.
- **Token Economics:** This feature helps you quantify the cost savings that you are achieving through HasMCP's context window optimization features. It shows you how much you are saving on LLM inference costs by pruning and optimizing your API responses.
- **Streaming Debug Console:** This feature provides a real-time stream of events from your MCP server, allowing you to see what's happening as it happens. This is an invaluable tool for debugging.
- **Payload Inspector:** This feature allows you to see the "before" and "after" of your data transformations. You can see the original, raw JSON response from your API, and the final, optimized JSON that is sent to the LLM. 
- **Error Tracing:** Capture full stack traces and raw payloads for failed tool calls to speed up debugging in production.

### Multi-tenant Organization Management

Designed for teams and large enterprises, this feature provides complete isolation and independent management for multiple workspaces.

- **What it is:** A robust governance system for creating and managing separate "Organizations" within a single HasMCP instance.
- **Why it's important:** Enterprises need to ensure that different departments or client projects are strictly isolated for security, compliance, and billing purposes.
- **How it works:** Each organization is a dedicated tenant with its own set of MCP servers, tool definitions, secrets vault, and billing configuration. Users can belong to multiple organizations and switch between them with a single click.
- **Key benefits:**
  - **Strict Security Isolation:** Data and secrets from one team are never visible to another, ensuring zero cross-tenant leakage.
  - **Tailored Governance:** Apply different configurations and policies to different organizations based on their sensitivity.
  - **Flexible Hierarchy:** Easily scale from a small team to a global enterprise with thousands of independent projects.

### Advanced Role-Based Access Control (RBAC)

Take full control over your platform security with granular permission management for every user and group.

- **What it is:** A comprehensive system for defining who can view, use, or manage specific AI tools and administrative settings.
- **Why it's important:** For security compliance (like SOC2 or GDPR), you must be able to enforce the "principle of least privilege"—ensuring that developers only have access to the secrets and tools they need.
- **How it works:** Administrators can assign predefined roles (Owner, Admin, Developer, Viewer) or create custom groups with tailored access levels. Permissions can be scoped to the entire organization or restricted down to individual MCP servers.
- **Key benefits:**
  - **Enterprise Compliance:** Maintain detailed audit trails of user access and administrative changes for regulatory filings.
  - **Secure Collaboration:** Enable large teams to build and deploy tools safely without compromising master secrets.
  - **Simplified Oversight:** Manage permissions for entire departments at once using standardized group profiles.

### Unified API Key Management

Securely integrate HasMCP into your own products and infrastructure with a centralized API key management hub.

- **What it is:** A streamlined system for generating, rotating, and monitoring API keys that allow programmatic access to your MCP servers.
- **Why it's important:** To build your own AI-powered applications on top of HasMCP, you need secure authentication tokens that can be easily managed and revoked.
- **How it works:** Generate keys specifically for backend services or CI/CD pipelines. Set expiration dates and scope each key to specific organizations or toolsets. Monitor the real-time usage and latency of every key in the Observability dashboard.
- **Key benefits:**
  - **Safe Automation:** Build your own AI wrappers and services with the confidence that your backend access is secure.
  - **Dynamic Key Lifecycle:** Instantly revoke or rotate keys if a compromise is suspected, without any downtime.
  - **Detailed Usage Monitoring:** See exactly which of your internal applications is consuming most of your AI budget.

### Usage-based Billing & Subscriptions

A transparent and flexible billing system integrated directly with Stripe to track and manage your AI infrastructure costs.

- **What it is:** A real-time tracking and automated invoicing engine for organization-level subscriptions and resource consumption.
- **Why it's important:** Predictable costs and clear visibility into AI spending are essential for budgeting and scaling enterprise AI initiatives.
- **How it works:** HasMCP tracks organization counts, tool call volume, and token consumption headers. It provides a real-time dashboard of current spending and future projections, with all payments handled securely through Stripe.
- **Key benefits:**
  - **Cost Transparency:** Drill down into which organizations and users are the primary drivers of your AI platform costs.
  - **Scalable Pricing:** Move from a free pilot to an enterprise-wide rollout with tiered plans that fit your size.
  - **Automated Invoicing:** Eliminate manual billing tasks with secure, automated subscription management.

### References

- https://docs.hasmcp.com
- https://hasmcp.com