Antigravity × Gemma 4：プロダクション・エージェントをローカルLLMで構築する

# LLM プロバイダー設定
NEXT_PUBLIC_LLM_PROVIDER=ollama
NEXT_PUBLIC_OLLAMA_BASE_URL=http://localhost:11434
NEXT_PUBLIC_OLLAMA_MODEL=gemma4:9b
 
# オプション：推論パラメータ
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

// antigravity.config.ts
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, // ミリ秒
};

# 既存サーバーを停止（Ctrl+C）
# 新規起動
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,
  });
 
  // Gemma 4 に送信
  const response = await client.generate({
    model: "gemma4:9b",
    prompt: buildPrompt(state.history),
    temperature: 0.7,
    top_p: 0.9,
    top_k: 40,
    num_predict: 2048,
  });
 
  // レスポンスをメモリに記録
  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("What are the main benefits of local LLMs?");
console.log(result);

// src/agents/tools.ts
import { Tool } from "@antigravity/agentkit";
 
export const searchTool: Tool = {
  name: "web_search",
  description: "Search the web for current information",
  inputSchema: {
    type: "object",
    properties: {
      query: {
        type: "string",
        description: "Search query",
      },
    },
    required: ["query"],
  },
  execute: async (params: { query: string }) => {
    // 実装：外部API（Serper、SerpAPI など）呼び出し
    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: "SQL query (SELECT only)",
      },
    },
    required: ["sql"],
  },
  execute: async (params: { sql: string }) => {
    // 実装：DB接続、クエリ実行
    const db = getDBConnection();
    const result = await db.query(params.sql);
    return result;
  },
};
 
export const calculateTool: Tool = {
  name: "calculate",
  description: "Perform mathematical calculations",
  inputSchema: {
    type: "object",
    properties: {
      expression: {
        type: "string",
        description: "Math expression (e.g., '2 + 2 * 3')",
      },
    },
    required: ["expression"],
  },
  execute: async (params: { expression: string }) => {
    // 実装：計算エンジン（evalは安全性考慮が必須）
    const result = safeEval(params.expression);
    return { result };
  },
};

// src/agents/GemmaAgentWithTools.ts
import { Agent, AgentState, Tool } from "@antigravity/agentkit";
import { OllamaClient } from "@ollama/sdk";
import { searchTool, databaseQueryTool, calculateTool } from "./tools";
 
export class GemmaProductionAgent {
  private agent: Agent;
  private ollama: OllamaClient;
 
  constructor() {
    this.ollama = new OllamaClient({
      baseUrl: "http://localhost:11434",
    });
 
    this.agent = new Agent({
      model: "gemma4:9b",
      llmClient: this.ollama,
      tools: [searchTool, databaseQueryTool, calculateTool],
      maxIterations: 10,
      verbose: true,
    });
  }
 
  async run(input: string): Promise<string> {
    const state: AgentState = {
      input,
      messages: [],
      toolCalls: [],
      scratchpad: "",
    };
 
    // ループ：LLMが「終了」と言うまで繰り返す
    for (let i = 0; i < this.agent.maxIterations; i++) {
      // LLMに「何をする？」と聞く
      const response = await this.agent.step(state);
 
      if (response.action === "finish") {
        return response.thought;
      }
 
      if (response.action === "tool") {
        // ツール実行
        const toolName = response.toolName;
        const toolInput = response.toolInput;
 
        const tool = this.agent.tools.find((t) => t.name === toolName);
        if (!tool) {
          state.scratchpad += `Tool ${toolName} not found.\n`;
          continue;
        }
 
        const toolResult = await tool.execute(toolInput);
        state.messages.push({
          role: "tool",
          toolName,
          result: toolResult,
        });
 
        state.scratchpad += `Tool: ${toolName}\nInput: ${JSON.stringify(toolInput)}\nResult: ${JSON.stringify(toolResult)}\n`;
      }
    }
 
    throw new Error("Max iterations reached");
  }
}

const agent = new GemmaProductionAgent();
 
const result = await agent.run(
  "Search for the latest Gemma 4 benchmarks and tell me how it compares to Llama 3."
);
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);
    this.taskQueue.sort(
      (a, b) =>
        ({ high: 0, medium: 1, low: 2 }[b.priority] -
          { high: 0, medium: 1, low: 2 }[a.priority])
    );
 
    // 利用可能なエージェントを割り当て
    const availableAgent = Array.from(this.agents.values())[0];
    return await availableAgent.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つのエージェント
 
const tasks: Task[] = [
  {
    id: "task-1",
    description: "Analyze customer feedback from Q1 2026",
    priority: "high",
  },
  {
    id: "task-2",
    description: "Generate code documentation for the API module",
    priority: "medium",
  },
  {
    id: "task-3",
    description: "Summarize latest AI research papers",
    priority: "low",
  },
];
 
const results = await orchestrator.processBatch(tasks);
 
for (const [taskId, result] of results) {
  console.log(`${taskId}: ${result}`);
}

ollama run gemma4:9b --verbose "Summarize the following in three bullet points: ..."

// antigravity.config.ts
export const llmConfig = {
  model: "gemma4:9b",
  // コンテキスト長を 4096 に制限（デフォルト 8192）
  contextLength: 4096,
  // スライディングウィンドウ：古い会話を自動削除
  slidingWindow: true,
  windowSize: 2048, // 最新 2048 トークンのみ保持
};

const generateParams = {
  temperature: 0.7, // 多様性
  topP: 0.95, // nucleus sampling
  topK: 50, // 上位 K トークン
  repetitionPenalty: 1.1, // 同じトークンの繰り返し抑制
  frequencyPenalty: 0.0,
  presencePenalty: 0.0,
};

import NodeCache from "node-cache";
 
const cache = new NodeCache({ stdTTL: 3600 }); // 1時間
 
async function cachedGenerate(prompt: string): Promise<string> {
  const cacheKey = createHash("sha256").update(prompt).digest("hex");
 
  // キャッシュ確認
  const cached = cache.get(cacheKey);
  if (cached) return cached;
 
  // キャッシュなければ生成
  const response = await ollama.generate({
    model: "gemma4:9b",
    prompt,
  });
 
  // キャッシュに保存
  cache.set(cacheKey, response.response);
 
  return response.response;
}

await fetch(`${OLLAMA_BASE_URL}/api/generate`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "gemma4:9b",
    prompt,
    stream: false,
    // 30分間はメモリに載せたままにする（-1 で無期限、0 で即アンロード）
    keep_alive: "30m",
  }),
});

export async function warmUpModel(model: string): Promise<void> {
  try {
    await fetch(`${OLLAMA_BASE_URL}/api/generate`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ model, prompt: "ok", stream: false, keep_alive: "30m" }),
      signal: AbortSignal.timeout(120_000), // 初回ロードは長い。専用に長めの猶予を取る
    });
  } catch {
    // ウォームアップの失敗でプロセスを落とさない。次の実リクエストでロードされる
  }
}

# 同時に処理するリクエスト数
OLLAMA_NUM_PARALLEL=4
# 同時にメモリへ載せるモデル数（複数モデルを使い分ける場合のみ増やす）
OLLAMA_MAX_LOADED_MODELS=1

class Semaphore {
  private queue: Array<() => void> = [];
  private active = 0;
 
  constructor(private readonly limit: number) {}
 
  async run<T>(task: () => Promise<T>): Promise<T> {
    if (this.active >= this.limit) {
      await new Promise<void>((resolve) => this.queue.push(resolve));
    }
    this.active++;
    try {
      return await task();
    } finally {
      this.active--;
      this.queue.shift()?.();
    }
  }
}
 
// OLLAMA_NUM_PARALLEL と同じ値にそろえる
const llmGate = new Semaphore(4);
 
export function generate(prompt: string): Promise<string> {
  return llmGate.run(() => callOllama(prompt));
}

export async function streamGenerate(
  prompt: string,
  onToken: (token: string) => void,
  externalSignal: AbortSignal, // リクエストの切断シグナルを渡す
): Promise<void> {
  const controller = new AbortController();
  const abort = () => controller.abort();
  externalSignal.addEventListener("abort", abort, { once: true });
 
  try {
    const res = await fetch(`${OLLAMA_BASE_URL}/api/generate`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ model: "gemma4:9b", prompt, stream: true, keep_alive: "30m" }),
      signal: controller.signal,
    });
    if (!res.body) throw new Error("no response body");
 
    const reader = res.body.getReader();
    const decoder = new TextDecoder();
    let buffer = "";
 
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      buffer += decoder.decode(value, { stream: true });
 
      // Ollama は NDJSON を返す。行が完結した分だけ処理する
      const lines = buffer.split("\n");
      buffer = lines.pop() ?? "";
      for (const line of lines) {
        if (!line.trim()) continue;
        const chunk = JSON.parse(line) as { response?: string; done?: boolean };
        if (chunk.response) onToken(chunk.response);
      }
    }
  } finally {
    externalSignal.removeEventListener("abort", abort);
    controller.abort(); // 正常終了時もソケットを確実に閉じる
  }
}

const codeReviewAgent = await orchestrator.delegateTask({
  id: "code-review-1",
  description: `
Review the following pull request code for:
1. Security vulnerabilities
2. Performance issues
3. Code style adherence
4. Test coverage
 
Code:
${pullRequestCode}
`,
  priority: "high",
});

const docGenerationAgent = await orchestrator.delegateTask({
  id: "doc-gen-1",
  description: `
Generate comprehensive API documentation for:
- Endpoint: POST /api/agents
- Method: createAgent(config: AgentConfig)
- Include: description, parameters, return type, examples, error cases
 
Implementation code:
${implementationCode}
`,
  priority: "medium",
});

const testGenerationAgent = await orchestrator.delegateTask({
  id: "test-gen-1",
  description: `
Generate unit tests for the following function:
 
${functionCode}
 
Requirements:
- Use Jest framework
- Include happy path and edge cases
- Minimum 80% code coverage
- Add mocks for external dependencies
`,
  priority: "medium",
});