Hyperterse is a high-performance runtime server that transforms database queries into REST endpoints and MCP (Model Context Protocol) tools.

You describe your queries once, in a simple configuration file. Hyperterse does the rest:

• Generates individual, typed endpoints
• Validates inputs automatically
• Produces OpenAPI documentation
• Exposes queries safely to AI systems

No ORMs. No boilerplate. No exposed SQL.

Hyperterse is built with AI in mind.

• AI agents and assistants - Safely query databases through MCP without exposing raw SQL.
• LLM tool calling - Let models discover and invoke database operations autonomously.
• Retrieval-augmented generation (RAG) - Use structured database queries as reliable context.
• Conversational interfaces - Power chatbots that access live business data.
• AI-driven analytics - Enable models to generate insights through validated queries.
• Multi-agent systems - Share consistent database access across agents.
• Natural language to SQL pipelines - Bridge human input and databases using tool calls.
• AI dashboards - Query and visualize data dynamically.

• Database-backed APIs without boilerplate
• Lightweight microservices without ORM overhead
• Rapid prototyping with configuration-first workflows

Hyperterse comes several features that help you leverage accessing your data in a secure manner for your AI agents and LLMs.

Define the shape and intent of data access once, and let Hyperterse handle execution, validation, and exposure.

Connect your data to AI agents through discoverable, callable tools—without exposing SQL, schemas, or credentials.

Turn queries into production-ready APIs with typed inputs, predictable outputs, and built-in documentation.

Generate REST endpoints, OpenAPI specs, LLM-readable docs, and MCP tools from one configuration file.

Work across PostgreSQL, MySQL, and Redis using a consistent, unified interface.

Update queries and schemas with immediate feedback during development.

Ship a self-contained runtime that moves cleanly from local development to production.

Support everything from prototypes to multi-agent systems without changing your architecture.

Install Hyperterse with a single command:

curl -fsSL https://hyperterse.com/install | bash

Supported platforms:

• Linux (amd64, arm64, arm)
• macOS (Intel, Apple Silicon)
• Windows (amd64, arm64)

For more installation options, see the installation guide.

Create a configuration file:

name: my-api

adapters:
  my_database:
    connector: postgres
    connection_string: "postgresql://user:password@localhost:5432/mydb"

queries:
  get-user:
    use: my_database
    description: "Retrieve a user by email address"
    statement: |
      SELECT id, name, email, created_at
      FROM users
      WHERE email = {{ inputs.email }}
    inputs:
      email:
        type: string
        description: "User email address"

Start the server:

hyperterse run -f config.terse

Call the endpoint:

curl -X POST http://localhost:8080/query/get-user \
  -H "Content-Type: application/json" \
  -d '{"email": "user@example.com"}'

Response:

{
  "success": true,
  "error": "",
  "results": [
    {
      "id": 123,
      "name": "John Doe",
      "email": "user@example.com",
      "created_at": "2024-01-01T00:00:00Z"
    }
  ]
}

📚 Read the docs →

• Getting Started - Quick start guide and installation
• CLI Reference - Complete command-line interface reference
• Configuration Guide - Configuration file reference
• Guides - Practical guides for AI integration, OpenAPI, MCP, and caching
• Caching Guide - Executor-level query caching, TTL, and override strategy
• Concepts - Core concepts: adapters, queries, and inputs
• Databases - Database-specific documentation
• Deployment - Deployment guides for various platforms

When running, Hyperterse exposes several endpoints:

• OpenAPI Documentation: GET /docs - Interactive API documentation
• LLM Documentation: GET /llms.txt - AI-friendly documentation format
• MCP Protocol: POST /mcp - Model Context Protocol JSON-RPC endpoint

List available tools:

curl -X POST http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/list",
    "id": 1
  }'

Invoke a tool:

curl -X POST http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
      "name": "get-user-by-id",
      "arguments": {
        "userId": "123"
      }
    },
    "id": 1
  }'

queries:
  get-user-by-id:
    use: user_db
    description: "Retrieve user information by ID"
    statement: |
      SELECT id, name, email, created_at
      FROM users
      WHERE id = {{ inputs.userId }}

queries:
  daily-stats:
    description: "Daily statistics over a date range"
    statement: |
      SELECT
        DATE(created_at) AS date,
        COUNT(*) AS total_events,
        COUNT(DISTINCT user_id) AS unique_users
      FROM events
      WHERE created_at BETWEEN {{ inputs.startDate }} AND {{ inputs.endDate }}
      GROUP BY DATE(created_at)
      ORDER BY date DESC

Run:

hyperterse run -f config.terse

Development mode (hot reload):

hyperterse dev -f config.terse

Validate configuration:

hyperterse validate -f config.terse

Generate artifacts:

hyperterse generate llms -f config.terse
hyperterse generate skills -f config.terse

Initialize:

hyperterse init

Upgrade:

hyperterse upgrade

Export:

hyperterse export -f config.terse -o dist

Hyperterse uses a simple YAML-like configuration format (.terse files) to define your database adapters and queries.

Supported input types: string, int, float, boolean, uuid, datetime

Template syntax:

WHERE price <= {{ inputs.maxPrice }}

Optional inputs:

optional: true
default: "20"

Multiple databases: Hyperterse supports multiple adapters in a single configuration file.

For complete configuration reference, see the configuration guide.

Hyperterse is designed with security as a baseline:

• 🔒 Credentials are never exposed - Connection strings stay server-side
• 🛡️ SQL is never returned to clients - Raw queries remain hidden
• ✅ Inputs are validated and escaped - Strong typing prevents injection
• 🔇 Errors are sanitized by default - Internal details stay internal

For production deployments, place Hyperterse behind a reverse proxy for authentication, rate limiting, and TLS. See the production security guide for best practices.

Contributions are welcome! We appreciate your help in making Hyperterse better.

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Add tests for your changes
4. Ensure code follows standard Go formatting
5. Open a pull request

Please keep changes focused and well-tested. For major changes, open an issue first to discuss your proposal. See CONTRIBUTING.md for detailed development guidelines.

Please note: By participating in this project, you agree to abide by our Code of Conduct. We are committed to providing a welcoming and inclusive environment for all contributors.

• 🌐 Website: hyperterse.com
• 📖 Documentation: docs.hyperterse.com
• 🐛 Issues: GitHub Issues
• 💬 Discussions: GitHub Discussions