# Helicone MCP for AI Agents AI Agent Connect > Helicone MCP lets you monitor LLM usage, track costs, and manage prompts directly through your AI agent. It connects your Helicone account to your agent so you can see real-time data on request latency, spend, and user feedback without switching tabs. It's built for teams who need to see exactly what's happening with their AI infrastructure. ## Overview - **Category:** ai-frontier - **Price:** Free - **Endpoint:** https://edge.vinkius.com/vk_preview_BY11i3Opi4Qq9KtIJUGQpInAaXPfnwFfbeNDvYuq/ai-agent-connect - **Tags:** llm-observability, request-logging, cost-analysis, latency-tracking, prompt-management, ai-gateway ## Description You're running LLM-powered features and need to know what's actually happening under the hood. Instead of jumping between several different dashboards to see if your costs are spiking or if a specific prompt is causing a delay, you can just ask your agent. This Connector gives your agent a direct line into your Helicone account. You can pull up a breakdown of how much you're spending on specific models or identify which users are hitting your limits the hardest. If a user reports a weird response, you can trace the entire multi-turn session to see exactly where the logic broke down. It handles the heavy lifting of digging through proxy logs so you can focus on refining your prompts and improving the model's performance. Because it's part of the Vinkius catalog, you can get this running in minutes and start querying your infrastructure as part of your normal conversation with your agent. It turns your observability data into a searchable, actionable conversation. ## Tools ### query_costs See a breakdown of the properties driving your account spending. This helps you identify exactly which features or models are consuming your budget. ### query_sessions Enumerate the rules exporting active billing. Use this to trace multi-turn sessions and see the billing rules for those calls. ### query_users Run a validation check to route gateway history. It helps you identify your most active human clients and their interaction history. ### get_prompt_versions Extract flags from prompt validations. Use this to see every version of a specific prompt and its history. ### query_feedback Inspect the internal data used to mitigate plan math issues. It lets you see the underlying logic for user feedback and critiques. ### query_latency Get a JSON payload for customer bindings on latency. It helps you pinpoint which providers are causing high Time To First Token delays. ### log_feedback Identify the active arrays for native hold parsing. Use this to pull the specific feedback logs you need to improve model grounding. ### query_prompts Retrieve cloud logging traces for vault limits. It helps you see the history and specific limits of your prompts. ### list_properties Identify the active arrays spanning gateway authentication. Use this to see the properties and settings of your gateway. ### query_requests Find bounded records inside the Helicone platform. It lets you see specific request logs to debug issues. ## Prompt Examples **Prompt:** ``` How much did we spend on GPT-4o yesterday? ``` **Response:** ``` Yesterday, you spent a total of **$42.15** on GPT-4o across 12,450 requests. The largest portion came from the 'Customer Support' feature tag (**$28.40**). Would you like a breakdown by user? ``` **Prompt:** ``` Show me the 10 slowest requests from the last hour ``` **Response:** ``` I've identified the 10 slowest requests. * **Highest TTFT:** 4.2s (anthropic.claude-3-opus) * **Average Latency:** 3.1s Would you like to inspect the prompt for the slowest one? ``` **Prompt:** ``` List all versions for the 'customer-service-bot' prompt ``` **Response:** ``` Found **5 versions** for 'customer-service-bot'. * **Version 5 (latest):** Deployed 2 days ago with updated grounding rules. * **Version 4:** Active for 3 months. I can fetch the exact instruction text for any version. ``` ## Capabilities ### Track real-time LLM spending See exactly where your budget is going by model, user, or custom tag. ### Inspect detailed request logs Pull up specific request details to debug issues in your AI gateway. ### Measure time to first token Identify which upstream providers are causing high latency for your users. ### Manage prompt versions See the history of your instructions and how they have changed over time. ### Trace multi-turn agent sessions Follow a full conversation history to see where complex logic breaks down. ### Log user feedback Retrieve thumbs up and down critiques to improve your model's grounding. ## Use Cases ### The 'Where's the money going?' check A product owner asks the agent to find out which feature is costing the most and gets a breakdown by tag using query_costs. ### The 'Why is it so slow?' investigation An engineer asks for the 10 slowest requests from the last hour to find a bottleneck in a specific provider using query_latency. ### The 'Why did it hallucinate?' debug A dev uses the agent to trace a specific user session to see the exact prompts that led to a bad output using query_sessions. ### The 'Is the new prompt better?' audit A team compares prompt versions to see how recent changes affected the grounding rules using get_prompt_versions. ## Benefits - Stop guessing about costs. Use query_costs to see exactly where your budget is going by model or user. - Fix slow responses faster. Use query_latency to pinpoint which providers are causing high Time To First Token delays. - Debug complex agent loops. Use query_sessions to trace multi-turn conversations and find where the logic fails. - Manage prompt iterations easily. Use get_prompt_versions to see how your instructions have changed over time. - Improve model accuracy. Use query_feedback and log_feedback to see real user critiques and RLHF data. - Identify your best users. Use query_users to see which clients are interacting most with your AI features. ## How It Works The bottom line is you get a conversational interface for your entire LLM observability stack. 1. Subscribe to the Helicone MCP on Vinkius. 2. Provide your Helicone API Key in the configuration. 3. Ask your agent about your costs, latency, or specific logs. ## Frequently Asked Questions **How does the Helicone MCP help with my AI budget?** It gives you a direct way to query your spending. You can ask your agent for cost breakdowns by model, user, or custom tags to see exactly where your money is going. **Can I use the Helicone MCP to find slow prompts?** Yes. You can ask your agent to find the slowest requests from a specific timeframe. It will pull the latency data and can even show you the prompt that caused the delay. **Does the Helicone MCP support multi-turn conversation tracing?** It does. You can ask your agent to pull specific sessions to see the full history of a conversation. This is great for debugging complex agentic workflows. **How do I see user feedback through the Helicone MCP?** You can ask your agent to pull thumbs up or down critiques. It retrieves the logged feedback so you can see what users liked or disliked about your AI's responses. **Can the Helicone MCP show me different prompt versions?** Yes. You can ask your agent to list all versions of a specific prompt. It will show you the history of your instructions and when each version was deployed. **Is the Helicone MCP good for monitoring my AI gateway?** It's designed for that. It connects to your Helicone account to provide a conversational way to check request logs, latency, and gateway performance. **Can I see the exact prompt that caused a specific error?** Yes. Use the `query_requests` tool to fetch direct prompts and outputs from the proxy logs. You can filter by status or custom tags to find the exact interaction that needs debugging. **How do I track costs for a specific customer ID?** Ask your agent to `query_costs` and include your customer identity in the filter. Helicone maps costs per model and user, allowing you to see exactly how much each client is burning in LLM tokens. **Can my agent log human feedback into Helicone?** Absolutely. Use the `log_feedback` tool to inject offline Human-in-the-Loop verdicts or text critiques directly into Helicone's database, helping you refine your model's grounding over time.