Wann ein einzelner Claude-Prompt reicht — und wann du einen Agenten brauchst

// Typischer Single-Prompt-Call mit dem Anthropic SDK
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

async function classifyEmail(emailBody: string): Promise<string> {
  const message = await client.messages.create({
    model: "claude-opus-4-5",
    max_tokens: 64,
    messages: [
      {
        role: "user",
        content: `Klassifiziere diese E-Mail als genau eines von: [SUPPORT, SALES, SPAM, INTERN].
Antworte nur mit dem Label, kein weiterer Text.

E-Mail:
${emailBody}`,
      },
    ],
  });

  const block = message.content[0];
  if (block.type !== "text") throw new Error("Unexpected response type");
  return block.text.trim();
}

// Aufruf: O(1) API-Calls, deterministisch, guenstig
const label = await classifyEmail("Mein Passwort funktioniert nicht mehr...");
console.log(label); // => "SUPPORT"

// Vereinfachter Agentic Loop mit Tool Use
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const tools: Anthropic.Tool[] = [
  {
    name: "fetch_competitor_price",
    description: "Ruft den aktuellen Preis eines Wettbewerbers per Slug ab.",
    input_schema: {
      type: "object",
      properties: {
        competitor_slug: { type: "string" },
      },
      required: ["competitor_slug"],
    },
  },
  {
    name: "save_to_notion",
    description: "Speichert einen Markdown-Text in der Notion-Datenbank.",
    input_schema: {
      type: "object",
      properties: {
        title: { type: "string" },
        content: { type: "string" },
      },
      required: ["title", "content"],
    },
  },
];

async function fetchCompetitorPrice(slug: string): Promise<string> {
  const prices: Record<string, string> = {
    acme: "49 EUR/Monat",
    globex: "39 EUR/Monat",
    initech: "59 EUR/Monat",
  };
  return prices[slug] ?? "Preis nicht verfuegbar";
}

async function saveToNotion(title: string, content: string): Promise<string> {
  console.log(`[Notion] Gespeichert: "${title}"`);
  return "ok";
}

async function runCompetitorResearchAgent() {
  const messages: Anthropic.MessageParam[] = [
    {
      role: "user",
      content:
        "Recherchiere die Preise von acme, globex und initech. " +
        "Schreibe dann einen kurzen Vergleichsabschnitt und speichere ihn in Notion.",
    },
  ];

  while (true) {
    const response = await client.messages.create({
      model: "claude-opus-4-5",
      max_tokens: 1024,
      tools,
      messages,
    });

    if (response.stop_reason === "end_turn") {
      console.log("Agent abgeschlossen.");
      break;
    }

    if (response.stop_reason === "tool_use") {
      messages.push({ role: "assistant", content: response.content });

      const toolResults: Anthropic.ToolResultBlockParam[] = [];

      for (const block of response.content) {
        if (block.type !== "tool_use") continue;

        let result: string;
        if (block.name === "fetch_competitor_price") {
          const input = block.input as { competitor_slug: string };
          result = await fetchCompetitorPrice(input.competitor_slug);
        } else if (block.name === "save_to_notion") {
          const input = block.input as { title: string; content: string };
          result = await saveToNotion(input.title, input.content);
        } else {
          result = "Unbekanntes Tool";
        }

        toolResults.push({
          type: "tool_result",
          tool_use_id: block.id,
          content: result,
        });
      }

      messages.push({ role: "user", content: toolResults });
    }
  }
}

await runCompetitorResearchAgent();

// Feste Pipeline: Kein Agent, aber mehr als ein Prompt
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

async function singlePrompt(userContent: string): Promise<string> {
  const message = await client.messages.create({
    model: "claude-opus-4-5",
    max_tokens: 512,
    messages: [{ role: "user", content: userContent }],
  });
  const block = message.content[0];
  if (block.type !== "text") throw new Error("Unexpected response type");
  return block.text.trim();
}

async function generateBlogOutline(topic: string, audience: string) {
  // Schritt 1: Kernaussagen extrahieren
  const keyPoints = await singlePrompt(
    `Nenne 5 technische Kernaussagen zum Thema "${topic}" fuer ${audience}. Nur Stichpunkte.`
  );

  // Schritt 2: Gliederung bauen
  const outline = await singlePrompt(
    `Erstelle eine Blog-Gliederung mit H2 und H3 auf Basis dieser Punkte:
${keyPoints}`
  );

  // Schritt 3: SEO-Titel vorschlagen
  const titles = await singlePrompt(
    `Schreibe 3 SEO-Titel-Varianten (max. 60 Zeichen) fuer diese Gliederung:
${outline}`
  );

  return { keyPoints, outline, titles };
}

// Der Code kontrolliert den Ablauf - das Modell nicht.
// Kein Loop, keine Tool-Calls, keine autonome Entscheidung.