Antigravity × Gemma 4: Building Production AI Agents with Local LLMs

NEXT_PUBLIC_LLM_PROVIDER=ollama
NEXT_PUBLIC_OLLAMA_BASE_URL=http://localhost:11434
NEXT_PUBLIC_OLLAMA_MODEL=gemma4:9b
 
# Optional: inference parameters
NEXT_PUBLIC_OLLAMA_TEMPERATURE=0.7
NEXT_PUBLIC_OLLAMA_TOP_P=0.9
NEXT_PUBLIC_OLLAMA_TOP_K=40
NEXT_PUBLIC_OLLAMA_NUM_PREDICT=2048

export const llmConfig = {
  provider: "ollama",
  baseUrl: process.env.NEXT_PUBLIC_OLLAMA_BASE_URL || "http://localhost:11434",
  model: process.env.NEXT_PUBLIC_OLLAMA_MODEL || "gemma4:9b",
  temperature: parseFloat(process.env.NEXT_PUBLIC_OLLAMA_TEMPERATURE || "0.7"),
  topP: parseFloat(process.env.NEXT_PUBLIC_OLLAMA_TOP_P || "0.9"),
  topK: parseInt(process.env.NEXT_PUBLIC_OLLAMA_TOP_K || "40", 10),
  numPredict: parseInt(process.env.NEXT_PUBLIC_OLLAMA_NUM_PREDICT || "2048", 10),
};
 
export const agentConfig = {
  maxIterations: 10,
  verbose: true,
  timeout: 30000,
};

npm run dev

[Antigravity] Connected to Ollama at http://localhost:11434
[Antigravity] Model loaded: gemma4:9b

// src/agents/BasicGemma4Agent.ts
import { OllamaClient } from "@ollama/sdk";
 
const client = new OllamaClient({
  baseUrl: "http://localhost:11434",
});
 
interface AgentState {
  input: string;
  history: Array<{ role: string; content: string }>;
}
 
export async function basicAgent(input: string): Promise<string> {
  const state: AgentState = {
    input,
    history: [],
  };
 
  state.history.push({
    role: "user",
    content: input,
  });
 
  const response = await client.generate({
    model: "gemma4:9b",
    prompt: buildPrompt(state.history),
    temperature: 0.7,
  });
 
  state.history.push({
    role: "assistant",
    content: response.response,
  });
 
  return response.response;
}
 
function buildPrompt(history: Array<{ role: string; content: string }>): string {
  let prompt = "You are a helpful AI assistant.\n\n";
  for (const msg of history) {
    if (msg.role === "user") {
      prompt += `User: ${msg.content}\n`;
    } else {
      prompt += `Assistant: ${msg.content}\n`;
    }
  }
  prompt += "Assistant:";
  return prompt;
}

const result = await basicAgent("Explain quantum computing in 3 sentences.");
console.log(result);

// src/agents/tools.ts
import { Tool } from "@antigravity/agentkit";
 
export const searchTool: Tool = {
  name: "web_search",
  description: "Search the web for information",
  inputSchema: {
    type: "object",
    properties: {
      query: {
        type: "string",
        description: "Search query",
      },
    },
    required: ["query"],
  },
  execute: async (params: { query: string }) => {
    const response = await fetch(`https://api.example.com/search`, {
      method: "POST",
      headers: { "Authorization": `Bearer ${process.env.SEARCH_API_KEY}` },
      body: JSON.stringify({ q: params.query }),
    });
    return await response.json();
  },
};
 
export const databaseQueryTool: Tool = {
  name: "query_database",
  description: "Query the application database",
  inputSchema: {
    type: "object",
    properties: {
      sql: {
        type: "string",
        description: "SELECT-only SQL query",
      },
    },
    required: ["sql"],
  },
  execute: async (params: { sql: string }) => {
    const db = getDBConnection();
    return await db.query(params.sql);
  },
};
 
export const calculateTool: Tool = {
  name: "calculate",
  description: "Perform math",
  inputSchema: {
    type: "object",
    properties: {
      expression: {
        type: "string",
        description: "Math expression like '2 + 2'",
      },
    },
    required: ["expression"],
  },
  execute: async (params: { expression: string }) => {
    return { result: safeEval(params.expression) };
  },
};

// src/agents/GemmaAgentWithTools.ts
import { Agent, AgentState, Tool } from "@antigravity/agentkit";
import { searchTool, databaseQueryTool, calculateTool } from "./tools";
 
export class GemmaProductionAgent {
  private agent: Agent;
 
  constructor() {
    this.agent = new Agent({
      model: "gemma4:9b",
      tools: [searchTool, databaseQueryTool, calculateTool],
      maxIterations: 10,
      verbose: true,
    });
  }
 
  async run(input: string): Promise<string> {
    const state: AgentState = {
      input,
      messages: [],
      toolCalls: [],
      scratchpad: "",
    };
 
    for (let i = 0; i < this.agent.maxIterations; i++) {
      const response = await this.agent.step(state);
 
      if (response.action === "finish") {
        return response.thought;
      }
 
      if (response.action === "tool") {
        const tool = this.agent.tools.find(
          (t) => t.name === response.toolName
        );
        if (!tool) {
          state.scratchpad += `Tool ${response.toolName} not found.\n`;
          continue;
        }
 
        const toolResult = await tool.execute(response.toolInput);
        state.messages.push({
          role: "tool",
          toolName: response.toolName,
          result: toolResult,
        });
 
        state.scratchpad += `Tool: ${response.toolName}\nResult: ${JSON.stringify(toolResult)}\n`;
      }
    }
 
    throw new Error("Max iterations reached");
  }
}

const agent = new GemmaProductionAgent();
const result = await agent.run(
  "What's the current price of gold and how much is 5 kg worth?"
);
console.log(result);

// src/agents/MultiAgentOrchestrator.ts
import { GemmaProductionAgent } from "./GemmaProductionAgent";
 
interface Task {
  id: string;
  description: string;
  priority: "high" | "medium" | "low";
}
 
export class MultiAgentOrchestrator {
  private agents: Map<string, GemmaProductionAgent> = new Map();
  private taskQueue: Task[] = [];
 
  constructor(numAgents: number = 3) {
    for (let i = 0; i < numAgents; i++) {
      this.agents.set(`agent-${i}`, new GemmaProductionAgent());
    }
  }
 
  async delegateTask(task: Task): Promise<string> {
    this.taskQueue.push(task);
    const agent = Array.from(this.agents.values())[0];
    return await agent.run(task.description);
  }
 
  async processBatch(tasks: Task[]): Promise<Map<string, string>> {
    const results = new Map<string, string>();
 
    const promises = tasks.map(async (task) => {
      const agentArray = Array.from(this.agents.values());
      const agent = agentArray[Math.floor(Math.random() * agentArray.length)];
      const result = await agent.run(task.description);
      results.set(task.id, result);
    });
 
    await Promise.all(promises);
    return results;
  }
}

const orchestrator = new MultiAgentOrchestrator(3); // 3 parallel agents
 
const tasks: Task[] = [
  {
    id: "task-1",
    description: "Analyze Q1 customer feedback trends",
    priority: "high",
  },
  {
    id: "task-2",
    description: "Generate README for the REST API",
    priority: "medium",
  },
  {
    id: "task-3",
    description: "Summarize recent machine learning papers",
    priority: "low",
  },
];
 
const results = await orchestrator.processBatch(tasks);
 
results.forEach((result, taskId) => {
  console.log(`${taskId}: ${result}`);
});

export const llmConfig = {
  model: "gemma4:9b",
  contextLength: 4096, // Limit to 4K (default 8K)
  slidingWindow: true,
  windowSize: 2048, // Keep only latest 2K tokens
};

import NodeCache from "node-cache";
import { createHash } from "crypto";
 
const cache = new NodeCache({ stdTTL: 3600 });
 
async function cachedGenerate(prompt: string): Promise<string> {
  const cacheKey = createHash("sha256").update(prompt).digest("hex");
 
  const cached = cache.get(cacheKey);
  if (cached) return cached as string;
 
  const response = await ollama.generate({ model: "gemma4:9b", prompt });
  cache.set(cacheKey, response.response);
 
  return response.response;
}

const reviewResult = await agent.run(`
Review this PR code for security, performance, and style:
${pullRequestCode}
`);

const docs = await agent.run(`
Generate API docs for:
${apiImplementation}
Include: descriptions, parameters, examples, error cases
`);

const tests = await agent.run(`
Create Jest tests for:
${functionCode}
Aim for 80%+ coverage, include edge cases and mocks
`);