Ihr Agent liefert die Daten.
Formfeed macht das Dokument.

import { query } from '@anthropic-ai/claude-agent-sdk';

const prompt = 'Render invoice 2026-0042 for Olvarest GmbH: 8 hours of consulting at 120 EUR.';

for await (const message of query({
  prompt,
  options: {
    mcpServers: {
      formfeed: {
        command: 'npx',
        args: ['-y', '@formfeed/mcp'],
        env: { FORMFEED_API_KEY: process.env.FORMFEED_API_KEY! },
      },
    },
    allowedTools: ['mcp__formfeed__*'],
  },
})) {
  if (message.type === 'result' && message.subtype === 'success') {
    console.log(message.result);
  }
}

Vollständige Anleitung für Claude Agent SDK →

import asyncio
import os

from agents import Agent, Runner
from agents.mcp import MCPServerStdio


async def main() -> None:
    async with MCPServerStdio(
        name="formfeed",
        params={
            "command": "npx",
            "args": ["-y", "@formfeed/mcp"],
            "env": {"FORMFEED_API_KEY": os.environ["FORMFEED_API_KEY"]},
        },
        cache_tools_list=True,
    ) as formfeed:
        agent = Agent(
            name="Billing assistant",
            instructions="Create documents with the Formfeed tools. Read the schema first.",
            mcp_servers=[formfeed],
        )
        prompt = "Render invoice 2026-0042 for Olvarest GmbH: 8 hours of consulting at 120 EUR."
        result = await Runner.run(agent, prompt)
        print(result.final_output)


asyncio.run(main())

Vollständige Anleitung für OpenAI Agents SDK →

import { anthropic } from '@ai-sdk/anthropic';
import { createMCPClient } from '@ai-sdk/mcp';
import { Experimental_StdioMCPTransport } from '@ai-sdk/mcp/mcp-stdio';
import { generateText, stepCountIs } from 'ai';

const formfeed = await createMCPClient({
  transport: new Experimental_StdioMCPTransport({
    command: 'npx',
    args: ['-y', '@formfeed/mcp'],
    env: { FORMFEED_API_KEY: process.env.FORMFEED_API_KEY! },
  }),
});

try {
  const { text } = await generateText({
    model: anthropic('claude-opus-5-5'),
    tools: await formfeed.tools(),
    stopWhen: stepCountIs(8),
    prompt: 'Render the certificate for Jane Doe, course "Analytical Engines 101".',
  });
  console.log(text);
} finally {
  await formfeed.close();
}

Vollständige Anleitung für Vercel AI SDK →

import asyncio
import os

from langchain.agents import create_agent
from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient(
    {
        "formfeed": {
            "transport": "stdio",
            "command": "npx",
            "args": ["-y", "@formfeed/mcp"],
            "env": {"FORMFEED_API_KEY": os.environ["FORMFEED_API_KEY"]},
        }
    }
)


async def main() -> None:
    tools = await client.get_tools()
    agent = create_agent("anthropic:claude-opus-5-5", tools)
    prompt = "Render invoice 2026-0042 for Olvarest GmbH and return the link."
    result = await agent.ainvoke({"messages": [{"role": "user", "content": prompt}]})
    print(result["messages"][-1].content)


asyncio.run(main())

Vollständige Anleitung für LangChain and LangGraph →

import { anthropic } from '@ai-sdk/anthropic';
import { Agent } from '@mastra/core/agent';
import { MCPClient } from '@mastra/mcp';

const mcp = new MCPClient({
  servers: {
    formfeed: {
      command: 'npx',
      args: ['-y', '@formfeed/mcp'],
      env: { FORMFEED_API_KEY: process.env.FORMFEED_API_KEY! },
    },
  },
});

export const documentAgent = new Agent({
  name: 'Document agent',
  instructions: 'Render documents with the Formfeed tools. Read the template schema before you render.',
  model: anthropic('claude-opus-5-5'),
  tools: await mcp.listTools(),
});

Vollständige Anleitung für Mastra →

import os

from crewai import Agent, Crew, Task
from crewai.mcp import MCPServerStdio

clerk = Agent(
    role="Document clerk",
    goal="Produce finished PDFs from the workspace's Formfeed templates",
    backstory="You read a template's data schema before you render and never guess field names.",
    mcps=[
        MCPServerStdio(
            command="npx",
            args=["-y", "@formfeed/mcp"],
            env={"FORMFEED_API_KEY": os.environ["FORMFEED_API_KEY"]},
        )
    ],
)

task = Task(
    description="Render a certificate for Jane Doe, course Analytical Engines 101, dated today.",
    expected_output="The download URL of the certificate",
    agent=clerk,
)

print(Crew(agents=[clerk], tasks=[task]).kickoff())

Vollständige Anleitung für CrewAI →

import asyncio
import os

from anthropic import AsyncAnthropic
from anthropic.lib.tools.mcp import async_mcp_tool
from mcp import ClientSession
from mcp.client.stdio import StdioServerParameters, stdio_client

formfeed = StdioServerParameters(
    command="npx",
    args=["-y", "@formfeed/mcp"],
    env={"FORMFEED_API_KEY": os.environ["FORMFEED_API_KEY"]},
)
prompt = "Render the certificate for Jane Doe, course Analytical Engines 101."


async def main() -> None:
    client = AsyncAnthropic()
    async with stdio_client(formfeed) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            tools = (await session.list_tools()).tools
            runner = client.beta.messages.tool_runner(
                model="claude-opus-5-5",
                max_tokens=16000,
                tools=[async_mcp_tool(t, session) for t in tools],
                messages=[{"role": "user", "content": prompt}],
            )
            async for message in runner:
                print(message.content)


asyncio.run(main())

Vollständige Anleitung für Claude API →

import Anthropic from '@anthropic-ai/sdk';
import { betaZodTool } from '@anthropic-ai/sdk/helpers/beta/zod';
import { Formfeed } from '@formfeed/sdk';
import { z } from 'zod';

const anthropic = new Anthropic();
const formfeed = new Formfeed({ apiKey: process.env.FORMFEED_API_KEY! });

const renderInvoice = betaZodTool({
  name: 'render_invoice',
  description: 'Renders an invoice PDF with the invoice-de template and returns its download URL.',
  inputSchema: z.object({
    number: z.string(),
    customer: z.object({ name: z.string(), street: z.string(), zip: z.string(), city: z.string() }),
    lines: z.array(z.object({ description: z.string(), qty: z.number(), price: z.number() })),
  }),
  run: async (invoice) => {
    const render = await formfeed.renders.create({ template: 'invoice-de', data: { invoice } });
    const done = render.status === 'succeeded' ? render : await formfeed.renders.waitFor(render.id);
    return done.download_url ?? `Render ${done.id} failed: ${done.error?.message}`;
  },
});

const message = await anthropic.beta.messages.toolRunner({
  model: 'claude-opus-5-5',
  max_tokens: 16000,
  tools: [renderInvoice],
  messages: [
    {
      role: 'user',
      content: 'Invoice Olvarest GmbH, Beispielweg 2, 54321 Beispielstadt: 8 h consulting at 120 EUR. Number 2026-0042.',
    },
  ],
});
console.log(message.content);

Vollständige Anleitung für Plain tool calling →