# Alpic MCP > Alpic lets you manage your entire MCP infrastructure programmatically. You can build new projects, create isolated environments (dev, staging, prod), and deploy changes across all of them with a single command from your agent. It also handles monitoring everything—from tracking latency to setting secure environment variables—so you don't have to manually check dashboards or manage release cycles anymore. ## Overview - **Category:** friends-mcp - **Price:** Free - **Tags:** mcp-server, deployment, lifecycle-management, infrastructure-as-code, monitoring, automation ## Description This MCP gives your agent full control over the entire lifecycle of your deployed services. Need to spin up a new feature? You create a dedicated project, link it to its git repo, and then set up specific environments for dev testing, staging verification, and production rollout. It handles that whole chain of commands—deploying code, managing secrets like API keys, and even publishing the service so others can find it. When something breaks in prod, you don't just guess; your agent pulls logs and usage data to pinpoint the exact failure point. You control everything from project creation (`create_project`) to auditing resource usage (`get_project_analytics`). It’s built for teams that run multiple complex services and need continuous deployment without the human overhead. If managing 5+ MCP instances sounds like a nightmare, connecting your AI client through Vinkius gives you one centralized place to manage all of it. ## Tools ### add_variable Adds a specific configuration value, like an API key or database URL, to an environment for the service. ### create_environment Sets up a completely isolated testing area (like dev or staging) for a project within Alpic. ### get_tunnel_ticket Generates a temporary URL and token, allowing you to test the service locally without needing a full deployment cycle. ### create_project Establishes an entirely new, structured service project and links it to its required source code repository. ### delete_project Permanently removes a specified service project from your entire infrastructure setup. Use with extreme care. ### delete_variable Removes an old or unused configuration key and its value from a specific environment's settings. ### deploy_environment Pushes the latest code version to a selected deployment target (dev, staging, or prod) for immediate testing. ### get_deployment_logs Retrieves the full build output or startup logs for a given environment to find out why something failed. ### get_deployment Checks the current status and detailed history of any specific deployment run using its unique ID. ### get_project_analytics Retrieves usage data, performance trends, and health metrics for a given MCP project over time. ### get_project Fetches all configuration details and settings for a single service project before making any changes. ### get_server_info Confirms the operational status of the service and lists all available functions exposed by the current setup. ### list_environments Lists all existing operational environments for a project, showing their current status and unique URLs. ### list_projects Provides an overview of every service project and its associated deployment status across the entire account. ### list_teams Lists all organizational teams within your Alpic account, grouping different projects under common management structures. ### list_variables Outputs a list of configured variable keys for an environment so you can audit the current settings. ### publish_to_registry Makes your fully operational service project discoverable and visible to other users within the official MCP registry. ### update_project Changes metadata for a project, such as renaming it or pointing it to a different source code branch without redeploying. ## Prompt Examples **Prompt:** ``` List all active Alpic projects running on my account natively, then check the error rate metric for the first one listed. ``` **Response:** ``` Retrieving infrastructure topologies (`list_projects`). Found the 'CustomerSupport_AI' server project actively bound. Proceeding to fetch corresponding analytics (`get_project_analytics`)... Current metrics establish a < 1% error generation state mapping cleanly. ``` **Prompt:** ``` Deploy the staging environment for our main enterprise project mapped on isolated branches. ``` **Response:** ``` Starting systematic progression executing `deploy_environment`. The directive fired securely triggering asynchronous backend processing natively without interrupting visual processes. ``` **Prompt:** ``` Audit the credentials in our production environment. Provide exact details of variable schemas missing from active lists. ``` **Response:** ``` Auditing environment instances mapping arrays (`list_variables`). I have extracted the configured mapping elements excluding raw keys. The parameters indicate matching schemas with zero anomalies. ``` ## Capabilities ### Project Structure Management Create, read, update, and delete entire service projects, linking them directly to specific source code repositories. ### Environment Isolation and Provisioning Spin up completely separate deployment environments (dev, staging, prod) for a single project, ensuring changes in one area don't affect others. ### Secure Configuration Management Set or delete critical environment variables, like database URLs or API keys, and keep them stored securely across various environments. ### Automated Deployment Workflow Trigger new code versions to deploy instantly to any designated environment (dev, staging, prod) using one command. ### Observability and Debugging Fetch real-time deployment status, detailed logs for failures, or overall usage metrics like error rates and request counts. ### Local Development Tunneling Generate a temporary URL ticket that lets you test the service locally before pushing anything to any live environment. ## Use Cases ### The new payment gateway needs testing. A developer can't test the latest payment integration because it only works on isolated branches. They use `get_tunnel_ticket` to generate a local URL, bypass staging completely, and confirm the entire flow before requesting an official deployment. ### We need to roll back a service update. The latest code broke production because of a configuration mismatch. An agent checks `get_project` for the last known good configuration and uses `update_project` or triggers a targeted rollback deployment using `deploy_environment`. ### Audit all service credentials. The security team needs to verify every secret. They run `list_environments` first, then use `list_variables` on the critical production environment to ensure no stale or unneeded keys remain. ### Onboard a new microservice. A platform team needs to track a brand-new service. They start by running `create_project`, linking it to git, and then immediately use `get_server_info` to confirm the project is alive and reporting correctly. ## Benefits - Automate the entire deployment pipeline. Instead of manually running a build, then deploying to dev, and finally repeating it for staging, use `deploy_environment` to trigger changes across all environments with one command. - Keep sensitive data isolated. You can manage every variable—API keys, database strings, feature flags—using `add_variable`, guaranteeing that development secrets never accidentally leak into the production build. - Diagnose failures instantly. When a service breaks in staging, don't waste time guessing. Use `get_deployment_logs` and `get_project_analytics` to pull definitive proof of failure or performance degradation. - Speed up local testing dramatically. Before committing code, use `get_tunnel_ticket`. This gives you a working URL for immediate testing on your machine without having to deploy anything first. - Maintain visibility across the board. Use `list_projects` at any time. It provides an instant, high-level overview of every service running in your account and its current operational status. ## How It Works The bottom line is that your agent handles the full sequence: scope > setup > configure > deploy. 1. First, your agent lists all available teams (`list_teams`) to identify the correct scope for the new infrastructure. Then, it creates a specific project under that team using `create_project`, which links the service to its code base. 2. Next, you use `list_environments` and `add_variable` to provision separate testing areas (dev/staging) and inject all necessary secrets and configuration keys for those isolated instances. Finally, running `deploy_environment` pushes the latest code into place. ## Frequently Asked Questions **How do I check if my service is running correctly using get_server_info?** You use `get_server_info` to confirm operational status and list all currently exposed functions. This confirms the MCP is active before you try deploying or reading data. **What if I need to test my code locally before I run deploy_environment?** Use `get_tunnel_ticket` first. It generates a temporary URL and token, letting your agent test the service on your machine without affecting any live environments. **Can I update an environment variable using add_variable if it already exists?** Yes. `add_variable` is designed to manage existing configuration keys, allowing you to securely overwrite or set new values for specific project/environment combinations. **Which tool should I use to see all my running projects in one place? list_projects?** You must run `list_projects` first. It gives a complete overview of every service and its associated deployment status across your entire account. **If I want to audit environment variables before deploying a change, should I use `list_variables`?** Yes, running `list_variables` shows you every variable key assigned to an environment. You can check if critical secrets, like API keys or database URLs, are present and configured correctly for your project. **Before I run `create_project`, how do I find the correct team ID using `list_teams`?** You must call `list_teams` first. This returns all associated teams, giving you the necessary IDs to ensure your new MCP project is placed under the right organizational umbrella. **If my deployment fails, should I check `get_deployment` or use `get_deployment_logs`?** You need to use `get_deployment_logs`. While `get_deployment` tells you if the process succeeded or failed, the logs provide the actual build output and stack traces necessary for deep debugging. **How can I review performance trends and usage patterns using `get_project_analytics`?** This tool provides usage metrics, including request counts and latency history. Reviewing these data points helps you spot performance bottlenecks or track if a specific function is generating unexpected error rates. **Can I deploy environments from specific Git branches directly from the terminal?** Yes! You can operate `create_environment` mapping parameters matching your active branches, then instruct your agent to trigger the `deploy_environment` sync. **Are environment variables secured during deployment processes?** Absolutely. You can invoke `add_variable` providing exact tokens without storing them in repositories. They remain encrypted at rest and dynamically injected upon startup. **Can I test server configuration before final production merges?** Yes. Request your AI agent to trigger `get_tunnel_ticket` enabling you to natively tunnel local host environments through Alpic before pushing any true integration commits.