UBOS Asset Marketplace: Unleashing the Power of AI-Enhanced Terragrunt with the MCP Server

In the rapidly evolving landscape of Infrastructure as Code (IaC), efficiency, accuracy, and maintainability are paramount. Terragrunt, a thin wrapper for Terraform, helps keep your Terraform configurations DRY (Don’t Repeat Yourself) and organized. However, even with Terragrunt, challenges persist, especially when it comes to documentation, context-aware autocompletion, and staying updated with the latest issues and best practices. That’s where the UBOS Asset Marketplace and the Deno/TypeScript MCP (Model Context Protocol) Server for Terragrunt Docs come into play, offering a transformative approach to IaC management.

The Challenge: Bridging the Gap Between IaC and AI

Traditional IDE support for Terragrunt is often lacking. The VSCode Terraform plugin, while helpful, doesn’t fully recognize Terragrunt-specific blocks or provide comprehensive autocompletion. This limitation becomes even more pronounced when interacting with AI-powered autocompletion tools, which can sometimes yield incorrect results or false-positive linting errors. The core issue is the lack of real-time, contextually relevant information fed to these AI assistants.

The Solution: MCP Server for Terragrunt Docs

The MCP Server for Terragrunt Docs, built with Deno and TypeScript, addresses this challenge head-on. As an MCP provider, it exposes tools and resources that allow AI agents and other MCP clients to query information about Terragrunt documentation and development insights directly from the Terragrunt GitHub repository. This server acts as a crucial bridge, connecting your IaC workflows with the power of AI.

Key Features and Benefits:

• Real-time Documentation Access: Provides AI assistants with the latest Terragrunt documentation, ensuring accurate and up-to-date information.
• Issue Tracking: Enables AI agents to access open issues from the Terragrunt GitHub repository, helping developers stay informed about current challenges and discussions.
• Context-Aware Autocompletion: Improves the accuracy of AI-powered autocompletion by providing contextually relevant information, reducing errors and improving efficiency.
• Enhanced IDE Support: Complements existing IDE plugins by providing a richer, more Terragrunt-aware development experience.
• Streamlined IaC Workflows: Facilitates smoother and more efficient IaC workflows by integrating AI-powered assistance directly into the development process.
• Deno and TypeScript: Leverages the performance and security benefits of Deno and the type safety of TypeScript for a robust and reliable server.

Use Cases:

1. AI-Powered Autocompletion: Imagine typing a Terragrunt configuration and having an AI assistant instantly suggest the correct block, parameter, or value, drawing from the latest documentation and community best practices. This MCP server makes it possible.
2. Intelligent Linting: Say goodbye to false-positive linting errors. The MCP server provides AI agents with the context needed to accurately assess your Terragrunt configurations, ensuring compliance and reducing unnecessary warnings.
3. Documentation Lookup: Need to quickly understand a specific Terragrunt feature or configuration option? Simply ask your AI assistant to retrieve the relevant documentation from the MCP server, saving you time and effort.
4. Issue Triage: Stay on top of the latest Terragrunt issues and discussions. The MCP server allows AI agents to monitor the GitHub repository, identify potential problems, and proactively alert developers.
5. Knowledge Base Integration: Integrate the Terragrunt documentation seamlessly into your existing knowledge base or documentation system, making it easily accessible to your entire team.

Diving Deeper: Exploring the MCP Server Tools

The MCP Server provides a suite of powerful tools, each designed to address specific needs in the IaC development process:

• list-doc-categories: This tool retrieves all documentation categories from the Terragrunt docs. It’s your entry point for exploring the documentation structure and building navigation systems. Think of it as the table of contents for Terragrunt’s knowledge base.

  • Use Case: Building a documentation navigation system or exploring the available documentation structure.

• list-all-docs-by-category: Need to see all available documentation within a specific category? This tool provides an array of objects containing the name, link, and content of each document.

  • Use Case: Building a category-specific documentation viewer or scanning through all docs in a particular area.

• read-document-from-category: This tool fetches the complete content of a specific document from a given category. It’s ideal for implementing documentation search or referencing specific documentation within your application.

  • Use Case: Accessing the complete content of a specific document for documentation search or referencing purposes.

• read-all-docs-from-category: For a comprehensive view, this tool retrieves and merges all docs in a category into a single response. It’s perfect for building documentation search features or analyzing the complete documentation set for a specific topic.

  • Use Case: Building a documentation search feature or analyzing the complete documentation set for a specific topic.

• get-all-open-issues: Stay informed about the latest challenges and discussions in the Terragrunt project with this tool. It retrieves all open issues from the Terragrunt GitHub repo, providing details such as title, number, state, creation date, update date, body, and labels.

  • Use Case: Tracking or analyzing current issues in the Terragrunt project, building an issue dashboard, or performing issue triage.

Getting Started: Integrating the MCP Server into Your Workflow

Setting up the MCP Server is straightforward. Here’s a step-by-step guide:

1. Install Deno: Follow the Deno Installation Guide to install Deno on your system.

2. Clone the Repository: Clone the MCP server repository from GitHub:

   sh git clone https://github.com/Excoriate/mcp-terragrunt-docs.git cd mcp-terragrunt-docs

3. Set Your GitHub Token: Set your GitHub token as an environment variable. This token is required to access the Terragrunt GitHub repository.

   • On Unix/macOS:

     sh export GITHUB_TOKEN=ghp_xxx… # or GH_TOKEN or GITHUB_PERSONAL_ACCESS_TOKEN

   • On Windows (cmd):

     cmd set GITHUB_TOKEN=ghp_xxx…

   Note: You can also set the token in the .env file.

4. Run the MCP Server: You can run the server directly using Deno, using the justfile, or directly from JSR.

   • Directly using Deno:

     sh deno run -A main.ts

   • Using the justfile:

     sh just run

   • Using JSR:

     sh

     export your github token

     export GITHUB_TOKEN=ghp_xxx…

     run it

     deno run -A jsr:@excoriate/mcp-terragrunt-docs@0.1.0

Integration with Claude Desktop

To seamlessly integrate the MCP Server with Claude Desktop, add the following configuration to your claude_desktop_config.json:

Using Deno

{ “mcpServers”: { “terragrunt_docs”: { “command”: “deno”, “args”: [ “run”, “-A”, “main.ts” ], “env”: { “GITHUB_TOKEN”: “<YOUR_TOKEN>” } } } }

Using Docker

{ “mcpServers”: { “terragrunt_docs”: { “command”: “docker”, “args”: [ “run”, “-e”, “GITHUB_TOKEN=<YOUR_TOKEN>”, “mcp-terragrunt-docs” ], “env”: { “GITHUB_TOKEN”: “<YOUR_TOKEN>” } } } }

Using JSR

{ “mcpServers”: { “terragrunt_docs”: { “command”: “deno”, “args”: [ “run”, “-A”, “jsr:@excoriate/mcp-terragrunt-docs@0.1.0” ], “env”: { “GITHUB_TOKEN”: “<YOUR_TOKEN>” } } } }

Dockerizing the MCP Server

For containerized deployments, you can build and run the MCP Server using Docker:

1. Build the Docker Image:

   sh docker build -t mcp-terragrunt-docs .

2. Run the MCP Server in Docker:

   sh docker run -it --rm
   -e GITHUB_TOKEN=ghp_xxx…
   mcp-terragrunt-docs

   • Replace ghp_xxx... with your GitHub Personal Access Token with appropriate permissions.
   • You can also use GH_TOKEN or GITHUB_PERSONAL_ACCESS_TOKEN as the environment variable name.
   • If you want to use a local .env file, you can pass it with --env-file .env.

UBOS: Your Full-Stack AI Agent Development Platform

The MCP Server for Terragrunt Docs is just one example of how UBOS is revolutionizing AI agent development. UBOS provides a comprehensive platform for orchestrating AI Agents, connecting them with your enterprise data, building custom AI Agents with your LLM model, and creating sophisticated Multi-Agent Systems. With UBOS, you can:

• Orchestrate AI Agents: Design and manage complex AI agent workflows with ease.
• Connect to Enterprise Data: Seamlessly integrate AI agents with your existing data sources.
• Build Custom AI Agents: Create tailored AI agents that meet your specific business needs.
• Develop Multi-Agent Systems: Harness the power of collaborative AI with multi-agent systems.

Contributing and Security

The MCP Server is an open-source project, and contributions are welcome! See docs/CONTRIBUTING.md for detailed contribution guidelines. Security is a top priority, and the project follows responsible disclosure guidelines. See SECURITY.md for the project’s security policy.

License

This project is licensed under the MIT License, promoting open collaboration and innovation.

Conclusion: Embrace the Future of IaC with AI

The UBOS Asset Marketplace and the Deno/TypeScript MCP Server for Terragrunt Docs represent a significant leap forward in the evolution of Infrastructure as Code. By bridging the gap between IaC and AI, this solution empowers developers to build more efficient, accurate, and maintainable infrastructure. Embrace the future of IaC and unlock the full potential of your Terragrunt configurations with the power of AI and the UBOS platform.