Build with Hikigai

Getting Started

Hikigai provides a simple way to deploy AI agents powered by Google's ADK and Vertex AI. You can create agents using our config-based approach (no code) or upload custom Python code.

Authentication

All API requests require authentication using a Bearer token. Get your API key from the dashboard.

curl -X GET "https://api.hikigai.com/v1/agents" \
  -H "Authorization: Bearer YOUR_API_KEY"

Deploy an Agent

Config-Based Deployment

The easiest way to deploy an agent. Just provide a name and instruction:

curl -X POST "https://api.hikigai.com/v1/agents/deploy/config" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-sentiment-analyzer",
    "instruction": "Analyze the sentiment of the given text and return positive, negative, or neutral with a confidence score.",
    "model": "gemini-2.0-flash",
    "category": "Natural Language Processing"
  }'

Code-Based Deployment

For custom logic, upload your agent.py file:

# agent.py
from google.adk.agents import Agent

def analyze_sentiment(text: str) -> dict:
    """Custom sentiment analysis logic."""
    return {"analyzed": True}

root_agent = Agent(
    name="my-agent",
    model="gemini-2.0-flash",
    instruction="Analyze sentiment...",
    tools=[analyze_sentiment],
)

Invoke an Agent

Once deployed, invoke your agent with a simple POST request:

curl -X POST "https://api.hikigai.com/v1/agents/my-sentiment-analyzer/invoke" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "I love this product! It works great."
  }'

Response

{
  "agent_id": "abc123",
  "response": "The sentiment is positive with high confidence (0.92).",
  "metadata": {
    "latency_ms": 245,
    "timestamp": "2024-01-15T10:30:00Z"
  }
}

Deploy an App

Hikigai lets you deploy full-stack web applications directly from a GitHub repository. The platform handles framework detection, Docker image building, container orchestration, and gives your app a live production URL — all in minutes.

Deploy via Console

The easiest way to deploy is through the Hikigai Console. Navigate to your project, click New App, and follow the 3-step wizard:

1. Source — Choose GitHub and select your repository and branch, or upload a ZIP file.
2. Configure — Review the auto-detected framework, set environment variables, choose CPU/memory resources, and configure the number of instances.
3. Deploy — Click deploy and watch real-time streaming build logs. Once complete, your app is live.

Deploy via API

You can also create and deploy apps programmatically using the Platform API:

# Step 1: Create an app in your project
curl -X POST "https://api.hikigai.ai/v1/projects/{project_id}/apps" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "display_name": "My Healthcare Portal",
    "framework": "nextjs"
  }'

# Step 2: Connect a GitHub repository
curl -X POST "https://api.hikigai.ai/v1/projects/{project_id}/apps/{app_id}/github/connect" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "installation_id": "136386010",
    "repo_full_name": "your-org/your-repo",
    "branch": "main"
  }'

# Step 3: Trigger a deployment
curl -X POST "https://api.hikigai.ai/v1/projects/{project_id}/apps/{app_id}/deploy" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "cpu": 256,
    "memory": 512,
    "min_instances": 1,
    "env_vars": {
      "NODE_ENV": "production"
    }
  }'

Supported Frameworks

The platform auto-detects your framework from the repository structure and generates an optimized, multi-stage Dockerfile tailored to it:

Build Pipeline

When you trigger a deployment, the following pipeline executes:

Real-time Build Logs

Monitor every phase of your build with server-sent event (SSE) streaming. Connect to the log stream endpoint to receive live updates in your terminal or application:

# Stream build logs in real time
curl -N "https://api.hikigai.ai/v1/projects/{project_id}/apps/{app_id}/deployments/{deploy_id}/logs/stream" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Response (SSE):
# data: {"phase": "BUILD", "message": "Step 1/8: FROM node:20-alpine AS base"}
# data: {"phase": "BUILD", "message": "Step 2/8: WORKDIR /app"}
# data: {"phase": "BUILD", "message": "Step 3/8: COPY package*.json ./"}
# data: {"phase": "DEPLOY", "message": "Task registered: arn:aws:ecs:..."}
# data: {"phase": "DEPLOY", "message": "Service updated, waiting for stability..."}
# data: {"phase": "COMPLETE", "message": "Deployment successful"}

Auto-Deploy on Git Push

Once your GitHub repository is connected, Hikigai can automatically redeploy your app whenever you push to the configured branch. The GitHub App webhook triggers a new build with the latest commit SHA, so your production app stays in sync with your code.

App Environment

Every deployed app receives a set of platform environment variables that are automatically injected into the container at runtime. These let your app interact with Hikigai services without any manual configuration.

Auto-Injected Variables

Using Platform Variables in Your App

Your deployed app can call any Hikigai agent using the auto-injected credentials. No API key management needed:

// Next.js API route — calling a Hikigai agent
export async function POST(req) {
  const { clinical_note } = await req.json();

  // These environment variables are auto-injected by the platform
  const response = await fetch(
    `${process.env.HIKIGAI_PLATFORM_URL}/v1/agents/icd-10-coder/invoke`,
    {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${process.env.HIKIGAI_API_KEY}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ message: clinical_note }),
    }
  );

  return Response.json(await response.json());
}

# FastAPI endpoint — calling a Hikigai agent
import os, httpx

@app.post("/analyze")
async def analyze(note: str):
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"{os.environ['HIKIGAI_PLATFORM_URL']}/v1/agents/icd-10-coder/invoke",
            headers={"Authorization": f"Bearer {os.environ['HIKIGAI_API_KEY']}"},
            json={"message": note},
        )
    return resp.json()

Custom Environment Variables

In addition to auto-injected variables, you can set your own environment variables during the Configure step. These are encrypted at rest and injected alongside platform variables.

MCP Servers

The Model Context Protocol (MCP) is an open standard that lets AI agents connect to external data sources and tools through a unified interface. Hikigai provides purpose-built MCP servers for the healthcare ecosystem, giving your agents real-time access to clinical data, terminology systems, and EHR platforms.

What is MCP?

MCP servers act as a bridge between your AI agents and healthcare data sources. Instead of building custom integrations for each EHR, terminology service, or clinical database, your agent connects to a standardized MCP server that handles authentication, data formatting, and compliance.

Available Healthcare MCP Servers

Connecting Agents to MCP Servers

When deploying an agent, specify which MCP servers it should connect to. The platform handles authentication and connection management:

from hikigai.agentsdk import AgentBuilder

agent = AgentBuilder("clinical-note-coder") \
    .instruction("Analyze clinical notes and suggest ICD-10 codes") \
    .model("gemini-2.0-flash") \
    .mcp_servers(["epic-ehr", "clinical-terminology"]) \
    .build()

# The agent can now:
# - Pull patient context from Epic EHR
# - Look up and validate ICD-10 codes
# - Cross-reference SNOMED CT mappings

# Invoking an MCP-connected agent
from hikigai.appsdk import AppClient

client = AppClient()
result = client.agent("clinical-note-coder").invoke(
    clinical_note="Patient presents with acute chest pain...",
    context={
        "patient_mrn": "MRN12345",     # Agent uses Epic EHR MCP to pull patient data
        "encounter_id": "ENC-67890",   # Agent fetches encounter context automatically
    }
)

print(result.codes)
# [{"code": "R07.9", "description": "Chest pain, unspecified", "confidence": 0.94}]

Platform API Reference

SDKs

Official SDKs for popular languages:

Rate Limits

Rate limits vary by plan. Exceeding limits returns HTTP 429.