Andy AI CLI

Generate production-ready Noundry code with AI-powered natural language commands. Powered by CodeLlama-7B with LlamaSharp.

Terminal
# Install Andy CLI globally
$ dotnet tool install -g Noundry.Andy
# Authenticate with your Noundry account
$ andy auth login
# Start generating code!
$ andy generate "form UI using Noundry.UI with fields: name, email"

Powerful AI-Driven Development

Everything you need to accelerate .NET development

Natural Language Generation

Describe what you need in plain English. Andy understands and generates the right code using CodeLlama-7B.

Noundry.UI Integration

Generate complete forms with validation using Noundry TagHelpers and Tailwind CSS styling.

Smart File Placement

Analyzes your project structure and places files in the correct directories automatically.

Interactive Chat Mode

Conversational interface for iterative development. Refine and improve code through dialogue.

Template-Based

Uses proven templates for instant generation. No training requiredβ€”just describe and generate.

Production Ready

Generated code includes validation, error handling, and follows ASP.NET Core best practices.

MCP Integration

Access Noundry documentation in any coding agent via NoundryMCP - a hosted Model Context Protocol server at mcp.noundry.ai/mcp.

NoundryMCP - Documentation for Any Coding Agent

Access complete Noundry documentation directly in Claude, Cursor, or any MCP-compatible coding agent with our hosted Model Context Protocol server.

What is NoundryMCP?

NoundryMCP is a hosted Model Context Protocol server that provides real-time access to Noundry documentation, code examples, and best practices directly within your coding agent.

Key Features

  • Full-text search across all Noundry documentation
  • Seamless integration with Claude Code, Cursor, and other MCP-compatible agents
  • Always up-to-date with the latest Noundry releases
  • No installation required - it's hosted by Noundry

Server URL: https://mcp.noundry.ai/mcp

Add NoundryMCP to Your Coding Agent
# For Claude Code CLI
$ claude mcp add https://mcp.noundry.ai/mcp
# For Cursor IDE
Add to Cursor settings:
{
"mcpServers": {
"noundry": {
"url": "https://mcp.noundry.ai/mcp"
}
}
}
# Or use with any MCP-compatible agent
MCP Server: https://mcp.noundry.ai/mcp
# Example usage in your coding agent:
> "How do I use Noundry.UI form validation?"
πŸ€– Searching Noundry docs via MCP...
βœ… Found documentation and examples!

Universal Compatibility: Works with Claude Code, Cursor, Windsurf, and any coding agent that supports the Model Context Protocol standard.

Real-World Use Cases

See what you can build with Andy AI

Generate Contact Form with Validation

Create a complete form UI with Noundry TagHelpers, data annotations, and Tailwind CSS styling in seconds.

$ andy generate "form UI using Noundry.UI with fields: firstName, lastName, email, phone"
πŸ€– Processing with CodeLlama-7B...
πŸ“‹ Using template: Noundry.UI Form
✨ Created Models/ContactFormModel.cs
✨ Created Views/Contact/Create.cshtml
βœ… Form ready with validation!

What's Generated:

  • Model class with DataAnnotations validation
  • Razor view with Noundry TagHelpers
  • Client-side and server-side validation
  • Tailwind CSS responsive styling

Models/ContactFormModel.cs

using System.ComponentModel.DataAnnotations;

public class ContactFormModel
{
    [Required]
    [Display(Name = "First Name")]
    [StringLength(50)]
    public string FirstName { get; set; } = "";

    [Required]
    [EmailAddress]
    public string Email { get; set; } = "";

    [Phone]
    public string Phone { get; set; } = "";
}

Views/Contact/Create.cshtml

<noundry-card>
    <noundry-card-body>
        <form method="post">
            <noundry-text-input
                asp-for="FirstName"
                placeholder="Enter first name" />

            <noundry-text-input
                asp-for="Email"
                type="email" />

            <noundry-button type="submit">Submit</noundry-button>
        </form>
    </noundry-card-body>
</noundry-card>

Generate Service with CRUD Operations

Create a complete service layer with interface, dependency injection, and async methods following best practices.

$ andy generate "service for managing products with CRUD operations"
πŸ€– Processing with CodeLlama-7B...
πŸ“‹ Analyzing project structure...
✨ Created Services/IProductService.cs
✨ Created Services/ProductService.cs
βœ… Service ready with DI setup!

Features Included:

  • β€’ Interface-based design (IProductService)
  • β€’ Async CRUD methods (GetAllAsync, CreateAsync, etc.)
  • β€’ Dependency injection ready
  • β€’ Error handling and logging
  • β€’ Repository pattern integration

Services/ProductService.cs

public interface IProductService
{
    Task<IEnumerable<Product>> GetAllAsync();
    Task<Product?> GetByIdAsync(int id);
    Task<Product> CreateAsync(Product product);
    Task<Product> UpdateAsync(Product product);
    Task<bool> DeleteAsync(int id);
}

public class ProductService : IProductService
{
    private readonly IRepository<Product> _repository;
    private readonly ILogger<ProductService> _logger;

    public ProductService(
        IRepository<Product> repository,
        ILogger<ProductService> logger)
    {
        _repository = repository;
        _logger = logger;
    }

    public async Task<IEnumerable<Product>> GetAllAsync()
    {
        _logger.LogInformation("Fetching all products");
        return await _repository.GetAllAsync();
    }

    // Additional methods...
}

Generate REST API Controller

Create a complete API controller with authentication, proper HTTP verbs, and response types.

$ andy generate "REST API controller for user management with authentication"
πŸ€– Processing with CodeLlama-7B...
πŸ“‹ Template: ASP.NET Core API Controller
✨ Created Controllers/UserController.cs
βœ… API endpoints ready!

Generated Endpoints:

  • GET /api/user - Get all users
  • GET /api/user/{id} - Get user by ID
  • POST /api/user - Create user
  • PUT /api/user/{id} - Update user
  • DELETE /api/user/{id} - Delete user

Controllers/UserController.cs

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Authorization;

[ApiController]
[Route("api/[controller]")]
[Authorize]
public class UserController : ControllerBase
{
    private readonly IUserService _userService;

    public UserController(IUserService userService)
    {
        _userService = userService;
    }

    [HttpGet]
    public async Task<ActionResult<IEnumerable<User>>> GetUsers()
    {
        var users = await _userService.GetAllAsync();
        return Ok(users);
    }

    [HttpPost]
    public async Task<ActionResult<User>> CreateUser(User user)
    {
        var created = await _userService.CreateAsync(user);
        return CreatedAtAction(nameof(GetUser),
            new { id = created.Id }, created);
    }
}

Generate Noundry Data Table

Create a feature-rich data table with sorting, filtering, and action buttons using Noundry components.

$ andy generate "Noundry data table for products with sorting and filtering"
πŸ€– Processing with CodeLlama-7B...
πŸ“‹ Template: Noundry Data Table
✨ Created Views/Products/Index.cshtml
βœ… Interactive table ready!

Table Features:

  • β€’ Sortable columns
  • β€’ Search and filtering
  • β€’ Action buttons (Edit, Delete, View)
  • β€’ Responsive design
  • β€’ Badge indicators for stock status
  • β€’ Pagination support

Views/Products/Index.cshtml

<noundry-page-title>Products</noundry-page-title>

<noundry-toolbar>
    <noundry-search-box placeholder="Search..." />
    <noundry-button variant="primary">
        New Product
    </noundry-button>
</noundry-toolbar>

<noundry-data-table
    source="@Model"
    sortable="true"
    filterable="true">

    <noundry-column
        field="Name"
        title="Product Name"
        sortable="true" />

    <noundry-column
        field="Price"
        format="{0:C}"
        sortable="true" />

    <noundry-column title="Actions">
        <template>
            <noundry-button variant="info">View</noundry-button>
            <noundry-button variant="warning">Edit</noundry-button>
        </template>
    </noundry-column>
</noundry-data-table>

Interactive Chat Mode

Have a conversation with Andy to iteratively build and refine your code.

$ andy chat --context ./src
Starting Andy Chat Session
Project: Noundry | Directory: C:\Projects\MyApp\src
> Create a complete authentication flow with JWT tokens
πŸ€– Generating authentication components...
✨ Created: Services/AuthenticationService.cs
✨ Created: Models/LoginRequest.cs
✨ Created: Models/RegisterRequest.cs
✨ Created: Controllers/AuthController.cs
✨ Updated: Program.cs (added JWT configuration)
The authentication flow includes:
  • JWT token generation and validation
  • User registration with password hashing
  • Login endpoint with token refresh
  • Role-based authorization support
Would you like me to add two-factor authentication?
> Yes, add 2FA with email verification
πŸ€– Adding two-factor authentication...
✨ Created: Services/TwoFactorService.cs
✨ Created: Services/EmailService.cs
✨ Updated: Models/LoginRequest.cs (added 2FA code)
✨ Updated: AuthController.cs (added verify endpoint)
βœ… Two-factor authentication enabled!
Users will receive a 6-digit code via email during login.

Chat Mode Benefits

  • Iterative development through conversation
  • Context-aware suggestions
  • Refine existing code
  • Multi-file coordination

Common Chat Commands

andy chat
andy chat --context ./src
andy chat --model gpt-4
Press Ctrl+C to exit chat mode

Quick Command Reference

Essential Andy CLI commands

Authentication

andy auth login
andy auth logout
andy auth status

Code Generation

andy generate "..."
andy generate --dry-run
andy generate --output ./path

Interactive Mode

andy chat
andy chat --context ./src
andy chat --model gpt-4

Configuration

andy config list
andy config set key value
andy config get key

Usage & Limits

andy usage
andy quota
andy plan

Help & Info

andy help
andy version
andy docs

Ready to Accelerate Your Development?

Install Andy CLI and start generating production-ready code today.