AI Capabilities

Extending the virtual agent with custom tools

This use case shows how to give the Talqui virtual agent new capabilities — the ability to call your own systems, recognize patterns specific to your business, or integrate with external services — by deploying a backend-only plugin that exposes MCP tools. The plugin runs on your infrastructure, under your control, and Talqui simply discovers and invokes the tools you expose.

Contextualization

Imagine an e-commerce company that manages inventory in a proprietary system. Today, when a customer asks the virtual agent "Do you have this product in stock?" or "Where is my order from three days ago?", the agent cannot answer because it has no access to the company's systems. It falls back to a scripted response or hands off to a human.

With a custom AI Capabilities plugin, the company can teach the agent to:

• Recognize product availability directly from their inventory system
• Act by placing orders without human intervention
• Identify orders and track shipments in real-time
• Reason about customer data to make contextual recommendations

All of this happens without building a conversation widget, creating a settings page, or exposing REST routes. The agent simply gains new tools.

Objective

Deploy MCP tools that the virtual agent discovers and calls autonomously, scoped to your internal systems. The agent becomes capable of:

• Reading your internal databases and APIs
• Taking actions (creating orders, logging tickets, updating records)
• Making decisions based on real-time data from your systems
• Conducting business logic that was previously unavailable to automated procedures

What you'll build

A backend-only plugin that exposes an MCP endpoint:

You define what tools matter to your business and implement them however makes sense for your stack.

How it works

Step 1: Define your tools

Design MCP tools that the agent will call. Think about what information or actions your business needs the agent to have access to:

• inventory.check — query your stock system for product availability
• order.create — place an order in your system
• order.status — look up a customer's order and its current status
• customer.profile — fetch customer data for personalization

Each tool has a name, a description (which guides the agent when to call it), and JSON-Schema constraints for inputs.

Step 2: Implement the backend

Build a Node.js (or any language) service that implements the MCP protocol. Register your tools, connect them to your internal systems, and expose the MCP endpoint on a public HTTPS address.

Example structure:

your-ai-tools/
├── src/
│   ├── tools/
│   │   ├── inventory.ts        # inventory.check tool
│   │   ├── order.ts            # order.create, order.status tools
│   │   └── customer.ts         # customer.profile tool
│   ├── adapters/
│   │   ├── inventory-api.ts    # calls your inventory system
│   │   ├── order-service.ts    # calls your order system
│   │   └── crm-client.ts       # calls your CRM
│   ├── mcp-server.ts           # MCP server wiring
│   └── index.ts                # Express app
├── package.json
└── Dockerfile

Step 3: Deploy to your infrastructure

Host your MCP endpoint on your own servers — AWS, DigitalOcean, Kubernetes, on-prem, wherever makes sense. The only requirement is that it's publicly accessible over HTTPS and responds to MCP requests.

Step 4: Register with Talqui

Submit your plugin to Talqui with only the MCP address:

Email: developer@talqui.com
Subject: Plugin Submission: [Your Company] AI Capabilities

Plugin Name: [Your Company] AI Capabilities
Description: MCP tools for inventory, orders, and customer data.

--- DEPLOYMENT ADDRESSES ---

MCP Endpoint: https://tools.your-company.com/mcp

--- AUTHENTICATION & CONFIGURATION ---

Authentication Header: Authorization: Bearer your-secret-token
(if required; leave blank if public)

That's it. No widget, no settings, no REST routes — just the MCP endpoint.

Step 5: Tools become available in Talqui

Once approved:

1. Talqui's virtual agent discovers your tools via tools/list at your MCP endpoint
2. The tools appear in the Procedure Editor as available steps
3. Operators can build procedures that instruct the agent to call your tools
4. At runtime, the agent calls your tools directly when it makes sense for the conversation

The runtime flow

Key points

• Backend-only — a plugin can be purely MCP tools with no UI or REST surface.
• Your infrastructure — you host and maintain the MCP endpoint. Talqui does not store your data or provide infrastructure support.
• Autonomous — the agent discovers and calls your tools without operator intervention. No widget needed.
• Flexible — tools can read, write, or trigger any action in your systems.
• Reusable — the same tools can be used by different procedures and different conversations.

Infrastructure & support

If you want Talqui to handle infrastructure, consider building a full plugin with a backend that Talqui's homologation team can validate and support (see Getting Started); but for autonomous MCP-only tools under your control, you are responsible.

Example: complete tool definition

Here's what one MCP tool might look like:

{
  "name": "order.status",
  "description": "Get the current status and details of a customer order. Use this when a customer asks about their order delivery, status, or tracking information.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "orderId": {
        "type": "string",
        "description": "The order ID (e.g., 'ORD-12345')"
      },
      "customerId": {
        "type": "string",
        "description": "The customer ID who placed the order (optional, for verification)"
      }
    },
    "required": ["orderId"]
  }
}

When the agent calls this tool with an orderId, your backend looks it up in your order system, validates it, and returns:

{
  "orderId": "ORD-12345",
  "status": "shipped",
  "shippingDate": "2026-08-01",
  "estimatedDelivery": "2026-08-05",
  "carrier": "FedEx",
  "trackingNumber": "1234567890"
}

The agent reads this response and answers the customer naturally.

Comparison: when to use this pattern

You can combine patterns — a plugin can have all three — but the simplest path to agent automation is MCP-only.

Next steps

1. Review Backend › MCP to understand tool design and the MCP protocol.
2. Start with the MCP portion of the talqui-oss/talqui-plugin-example to see concrete tool implementations.
3. Build your tools, test them with the MCP Inspector, and deploy to your infrastructure.
4. Submit your MCP endpoint to Talqui via Submitting Your Plugin.

• Ice Cream ShopBackend + Widget for operators.Read
• Conversation ObserverRTM bridge for real-time events.Read
• BackendDeep dive into MCP tools and tool design.Read
• Submitting Your PluginRegister and publish.Read