# Umbrellar MCP > Umbrellar connects your AI client directly to your entire product and service infrastructure. Manage everything—from cloud server status checks and domain renewals to complex warranty claim processing, policy validation, and cross-platform data syncing. You talk to your agent; it performs actions across your full stack. ## Overview - **Category:** developer-tools - **Price:** Free - **Tags:** cloud-hosting, domain-management, managed-services, server-monitoring, infrastructure-management ## Description You connect your AI client directly to Umbrellar’s core operations. This means you don't have to jump between dashboards or manually run API calls for basic checks. Your agent handles everything across product lifecycle management, warranty processing, and data syncing—it just performs the actions you tell it to. **Process Claims:** When someone needs a claim filed, your AI client uses `create_claim` to submit and log all the necessary details into your system right away. If you need to follow up on an existing case, it'll use `get_claim` to pull up all the current status information for that specific warranty claim. You can also modify records after they’re filed; if notes change or a status needs adjusting, running `update_claim` lets your agent change existing claim details without starting over. **Manage Policies and Warranties:** Dealing with policies requires precision. To verify if a policy even exists before you proceed, the system runs `validate_policy`, matching the provided ID and order name against your records. If you need to pull up all the fine print on one specific plan, `get_policy` fetches detailed information using both its unique ID and its full name. When you're looking at the scope of what Umbrellar offers, `list_policies` pulls a complete list of every defined policy framework available across your platform. Similarly, to see all the coverage options you sell, `list_warranties` lists every single active or inactive warranty plan that your business maintains. If you're just trying to get a bird's-eye view of what exists in your catalog, `list_claims` pulls up a full list of every claim ever filed within your system for review. **Check Product Status:** Before anything else happens, you need to confirm coverage. Your agent uses `check_product_eligibility` to determine if a specific product meets all the requirements necessary for warranty coverage according to Umbrellar's ruleset. If the product is brand new and needs official documentation in your system, you run `register_product`, which adds that product into your main database, typically fulfilling manufacturer or OEM documentation needs. For keeping everything clean and up-to-date across different sales channels, running `sync_products` automatically transfers all necessary product data between Shopify and Umbrellar, making sure both records are totally aligned. Your AI client uses these tools to handle complex operations in sequence. You can ask it to get a warranty's specific details using `get_warranty`, or if you need general information on every single service package available across your company, it runs `list_warranties` and provides that data set. The system also gives you the power to look at all defined policy frameworks by running `list_policies`. When checking eligibility for a product, the agent doesn't just check; it confirms if the item qualifies using `check_product_eligibility`, which is key because coverage rules are complex and specific to the hardware or service. When you need to manage claims, the process moves from initial submission via `create_claim` to retrieval of status details with `get_claim`. If a claim needs changes—like adding an adjuster's note or changing its internal status—you simply invoke `update_claim`, and it handles the modification immediately. The platform also allows you to verify policy existence using both ID and order name through `validate_policy` before retrieving the full details with `get_policy`. For catalog management, remember that `sync_products` keeps your Shopify inventory in sync with Umbrellar's records, so you don't have data gaps. Furthermore, if you ever need to document a product that hasn't been officially registered yet, running `register_product` handles the creation of that record for future reference. ## Tools ### check_product_eligibility Determines if a specific product meets the requirements for warranty coverage. ### create_claim Submits and logs a brand new warranty claim into your system. ### get_claim Retrieves all current status details for an existing, specific warranty claim. ### get_policy Fetches detailed information about a precise warranty policy plan using its ID and name. ### get_warranty Gets specific details about an individual warranty plan or service package. ### list_claims Pulls a list of all claims filed within your system for review. ### list_policies Retrieves a list of all defined policy frameworks available in Umbrellar. ### list_warranties Lists every active and inactive warranty plan that your business offers. ### register_product Adds a new product into the system, typically for OEM or manufacturer documentation purposes. ### sync_products Automates the transfer of product data between Shopify and Umbrellar to keep records aligned. ### update_claim Modifies existing information on a warranty claim, such as adding notes or changing status. ### validate_policy Confirms whether a policy exists by matching the provided ID and order name. ## Prompt Examples **Prompt:** ``` List all my active cloud servers. ``` **Response:** ``` You have 2 active servers: 'Web-Node-1' (Running) and 'DB-Master' (Running). ``` **Prompt:** ``` Check the expiration date for the domain 'vinkius.com'. ``` **Response:** ``` The domain 'vinkius.com' is active and will expire on October 14th, 2027. ``` **Prompt:** ``` Show the resource usage for 'Web-Node-1'. ``` **Response:** ``` 'Web-Node-1' is currently using 45% CPU, 2.1GB of RAM, and 40GB of disk space. ``` ## Capabilities ### Process Claims Submit new claims using `create_claim`, retrieve details with `get_claim`, or update existing claim records using `update_claim`. ### Manage Policies and Warranties Verify policy existence via ID and name (`validate_policy`), fetch specific policy details (`get_policy`), or list all available plans using `list_policies` and `list_warranties`. ### Check Product Status Determine if a product qualifies for coverage with `check_product_eligibility`, or officially record it with `register_product`. ### Sync Data Across Platforms Keep your inventory current by syncing products between Shopify and Umbrellar using the `sync_products` tool. ## Use Cases ### A customer calls about an old machine's coverage. The agent doesn't need to know where to look. The user simply asks: 'Does this product qualify for warranty?' The agent runs `check_product_eligibility` and immediately reports the result, saving 15 minutes of back-and-forth searching. ### You just updated your Shopify inventory list. Instead of exporting a CSV and manually uploading it to Umbrellar, you prompt: 'Sync all new products from Shopify.' The agent runs `sync_products`, ensuring the data is live in both places with zero manual effort. ### A client insists their policy number is correct but the system rejects it. You use the AI to run `validate_policy`. By providing both the ID and order name, you confirm its existence immediately. This stops the support process from going down a dead-end path. ### Processing a large batch of warranty filings. Instead of creating claims one by one, you can ask your agent to `list_policies` first to ensure you have the right framework, and then use that data context to guide the creation of multiple claims via `create_claim`. ## Benefits - Stop juggling tabs. Instead of manually cross-referencing a customer's purchase date against the warranty terms in two different systems, use `check_product_eligibility` and get an immediate pass/fail status from your agent. - Never lose track of claims again. Running `list_claims` gives you a single source of truth for every case filed, eliminating the need to search through email threads or separate database views. - Keep inventory records current. The `sync_products` tool automatically handles data flow between Shopify and Umbrellar, meaning product updates happen in one go without manual CSV exports. - Speed up validation checks. Instead of guessing if a policy exists, use `validate_policy`. It confirms existence using both the ID and name, making your initial triage step instant and reliable. - Better documentation flow. When you onboard a new item, run `register_product` first. This establishes the necessary record so that subsequent claims can reference it accurately. ## How It Works The bottom line is that your AI client handles the API calls and data routing; you just talk to it. 1. Tell your AI agent exactly what needs to happen. For example: 'Check if Product X is eligible for warranty, then submit a claim.' 2. The agent interprets the request and calls the necessary Umbrellar tools (like `check_product_eligibility` followed by `create_claim`). 3. You get an immediate, conversational report back—the status of the eligibility check or the confirmation number for the new claim. ## Frequently Asked Questions **How do I know if my product qualifies for coverage using check_product_eligibility?** It runs a direct check against your registered inventory data. It tells you immediately if the item meets the warranty requirements or what is missing to qualify. **Can Umbrellar MCP Server list all my historical claims?** Yes, use `list_claims`. This tool pulls a consolidated view of every claim ever filed, letting you review your entire operational history in one go. **What is the difference between get_warranty and list_warranties?** `list_warranties` shows all plans you offer. `get_warranty`, however, fetches specific details for just one single plan you name or ID. **I need to update an old claim; should I use get_claim or update_claim?** First, run `get_claim` to pull up the current status and verify the details. Then, if changes are needed (like adding notes), you use `update_claim`. **If I have a brand new product, what's the first step before checking eligibility using register_product?** You must use `register_product` first. This command creates the initial official record for the item in our system. After registration is complete, your AI client can then check its eligibility or file a claim. **Before I try to process a claim, how do I confirm if my Policy ID exists using validate_policy?** You run `validate_policy`. This function checks the policy ID and order name combination against our current database. It confirms the policy's existence before you attempt any update or retrieval actions. **If my product inventory changes in Shopify, how do I keep Umbrellar's records up to date?** You need to run `sync_products`. This function connects your Shopify store directly with Umbrellar’s database. It automatically updates the product data on both ends, ensuring accuracy. **What command do I use if I want to see all possible warranty options available?** Use `list_warranties`. This pulls a comprehensive list of every active plan Umbrellar offers. It lets you compare coverage tiers and choose the right plan before registering a product. **Can I check the uptime status of my virtual machines?** Yes, just supply the VM ID and the agent will return its current operational status. **How do I query my registered domains?** Ask the AI to list all your domains, and it will fetch their expiration dates and current configurations. **Is it possible to reboot a server through the chat?** Server alteration commands like rebooting are disabled by default for safety, focusing the integration on observability.