Build an AI Agent

This guide walks you through building, testing, and deploying an AI agent that can call tools and maintain conversation memory. By the end, you'll have a deployed agent accessible via any OpenAI SDK client.

Uses: AI Agent, HTTP Request, Window Memory, API Endpoint, Return Time: ~15 minutes

• A Tensorify workspace at app.tensorify.io
• An OpenAI API key (or Anthropic, or any OpenAI-compatible provider)
• CLI installed if deploying locally: curl -fsSL https://cli.tensorify.io/install | sh

Create a new workflow from the dashboard. You'll see an empty canvas with a node palette on the left.

Drag an API Endpoint trigger onto the canvas. This creates a programmable HTTP endpoint for your agent.

Configure the trigger:

• Path: /v1 (for OpenAI-compatible access)
• Allowed Methods: GET, POST
• Response Mode: Use Workflow Response
• Protocol: OpenAI Chat (messages[] ↔ ChatCompletion)

Drag an AI Agent node onto the canvas. Connect the trigger's POST output handle to the agent's message input.

Configure the agent:

• Provider: OpenAI (or your preferred provider)
• Model: gpt-4o
• System Prompt: Write clear instructions for what the agent should do

Example system prompt for a research assistant:

You are a research assistant. When asked a question:
1. Search for relevant information using the available tools
2. Synthesize the findings into a clear, accurate answer
3. Cite your sources when possible

Be concise and factual. If you don't know something, say so.

Tools give your agent capabilities beyond text generation. Drag an HTTP Request node onto the canvas and connect it to the agent's Tools handle.

Configure the HTTP Request tool:

• Label: Search API (the agent sees this name)
• Method: GET
• URL: https://api.example.com/search?q={{ "{{ input.query }}" }}

You can connect multiple tools — each one appears as a new handle slot on the agent node. Common tool combinations:

• HTTP Request for API calls
• Code for custom Python logic
• MCP Server for connecting to MCP-compatible services

For multi-turn conversations, add a Window Memory node and connect it to the agent's Memory handle.

Configure:

• Window Size: 20 (keeps the last 20 messages)
• Persistent: true (survives workflow restarts)
• Session Key: session:{{ "{{ api_request.headers["x-tensorify-session-id"] }}" }} (scopes memory per session — the Playground and OpenAI SDK clients send this automatically)

Drag a Return node and connect the agent's response output to it. This sends the agent's answer back as the HTTP response.

Go to Settings > Environment Variables in the sidebar and add:

• OPENAI_API_KEY: Your OpenAI API key

1. Ensure your runner is connected (tensorify runner start)
2. Click Test in the canvas toolbar
3. Select the Return node as the target
4. Click Run to Selected

The agent will process the mock payload, potentially call tools, and return a response. Check the output in the test results panel.

Click Deploy in the toolbar:

1. Choose your execution mode: Tensorify Cloud (managed) or Self-Hosted (CLI runner)
2. Copy the trigger URL — this is your agent's endpoint

Your deployed agent is now accessible via the OpenAI SDK:

from openai import OpenAI

client = OpenAI(
    base_url="https://triggers.tensorify.io/h/YOUR_HOOK_ID/v1",
    api_key="your-bearer-token"  # the secret from your API trigger's auth settings
)

response = client.chat.completions.create(
    model="my-agent",
    messages=[
        {"role": "user", "content": "What are the latest trends in AI?"}
    ]
)

print(response.choices[0].message.content)

Open the Playground tab in the canvas bottom bar. The Playground detects your AI Agent node and automatically opens in Chat mode — this works with any trigger type, not just API Trigger.

Type a message and press Enter. You'll see the agent's response stream in real-time. The Playground manages session IDs automatically, so multi-turn conversations work out of the box.

• Enable streaming: See Streaming AI Responses for SSE setup with OpenAI SDKs and Vercel AI SDK
• Add more tools: Connect Code nodes for custom logic or MCP Server nodes for external integrations
• Upgrade memory: Switch to Qdrant Memory for semantic search over long conversation histories
• Deploy as an OpenAI endpoint: See Deploy as OpenAI Endpoint for full SDK integration details
• Choose the right trigger: See Choosing a Trigger for when to use API vs Webhook vs Manual

• AI Agent Reference — full settings and response format documentation
• Agent Memory Guide — deep dive into memory options
• Deploy as OpenAI Endpoint — full OpenAI SDK integration
• Streaming AI Responses — real-time SSE streaming
• Choosing a Trigger — trigger type guidance