Tools in Python schreiben.
Oder einen MCP-Server anbinden.
Integrierte Tools übernehmen Retrieval, die Projektdatenbank, andere Agenten und das Web. Jeder Aufruf erscheint im Trace des Runs.
Jede Python-Funktion wird zum Tool.
Schreib eine einfache Funktion unter tools/, synchron oder asynchron. Ein Parameter-Schema pflegst du nie von Hand.
- Unterstützte Typen
- str, int, float, bool, Listen, Dicts und Literal. Parameter ohne Type Hint gelten als String, ohne Default sind sie Pflicht.
- Der Docstring erklärt das Tool
- Daran erkennt das KI-Modell, wann es das Tool aufruft. Jeder Eintrag unter Args beschreibt einen Parameter.
- context bleibt außerhalb des Schemas
- Ein Parameter namens context bekommt den Run-Kontext. Das Modell sieht ihn nie.
- Referenz über den Modulpfad
- tools/orders.py liefert orders.create_return_label, und orders.* bindet jede öffentliche Funktion der Datei ein.
tools/orders.py
from typing import Literal
import httpx
async def create_return_label(
order_id: str,
reason: Literal["damaged", "wrong_item", "not_needed"],
context: dict,
) -> dict:
"""Create a prepaid return label for an order.
Args:
order_id: Order number from the customer, e.g. A-10442
reason: Why the customer is sending the order back
"""
async with httpx.AsyncClient() as client:
resp = await client.post(
f"https://api.shop.example/orders/{order_id}/returns",
json={"reason": reason, "customer": context["customer_id"]},
)
return resp.json()create_return_label: parameters sent to the model
{
"type": "object",
"properties": {
"order_id": {
"type": "string",
"description": "Order number from the customer, e.g. A-10442"
},
"reason": {
"enum": ["damaged", "wrong_item", "not_needed"],
"type": "string",
"description": "Why the customer is sending the order back"
}
},
"required": ["order_id", "reason"]
}MCP-Server anbinden. Auch im eigenen Netzwerk.
Trag Server unter mcp_servers ein, und der Agent nutzt ihre Tools wie seine eigenen.
- Secrets aus Variablen
- Headers lösen ${VAR} aus den Variablen des Environments und ${context.*} aus dem Run auf. Tokens stehen so nie im YAML.
- Server in deinem Netzwerk
- Mit bridge läuft die Verbindung über eine connic Bridge. Einen öffentlichen Endpoint braucht der Server nicht.
- Bei Bedarf gesucht
- discoverable: true indexiert die Tools des Servers. So bleiben auch große Tool-Sets aus dem Prompt.
- Anmeldung pro Person
- oauth schickt das eigene Access Token jedes Endnutzers mit. Nutzer verbinden sich einmal per Link aus deiner App oder aus dem Gespräch.
agents/order-support.yaml
name: order-support
model: connic/gpt-5.6-terra
tools:
- orders.*
- retrieval_query
mcp_servers:
- name: helpdesk
url: https://mcp.helpdesk.example.com/mcp
headers:
Authorization: "Bearer ${HELPDESK_TOKEN}"
tools:
- create_ticket
- add_comment
- name: warehouse
url: http://wms.internal:8080/mcp
bridge: ${WAREHOUSE_BRIDGE_ID}
- name: carrier-hub
url: https://mcp.carriers.example.com/mcp
discoverable: trueRetrieval, Datenbank und Web. Schon eingebaut.
Integrierte Tools fügst du über ihren Namen hinzu, ganz ohne Python. Sie arbeiten mit Retrieval, Datenbank und Agenten des aktuellen Environments.
Eigene Tools können dieselben Funktionen aus Python aufrufen, etwa um db_find in ein Tool für deinen Fachbereich zu packen.
agents/order-support.yaml
tools:
# Retrieval
- retrieval_query # search the project's retrieval
- retrieval_store # queue content for indexing
# Database
- db_find # query a collection with filters
- db_upsert # update the first match or insert
# Orchestration
- trigger_agent # start another agent, optionally wait
- trigger_agent_at # schedule a run up to 30 days ahead
# Web
- web_search # up to 10 results per call
- web_read_page # fetch a page as Markdown
- web_browser_* # open, click, type, screenshot, filesFestlegen, wann ein Tool läuft und wer den Aufruf freigibt.
Bedingungen, Freigaben und Hooks liegen in deinem Projekt, direkt neben den Tools, die sie absichern.
- Bedingungen
- Das KI-Modell sieht ein Tool nur, wenn sein Ausdruck für die Anfrage zutrifft.
- Freigaben
- approval.tools hält den Run vor einem passenden Aufruf an. Mit param.amount > 100 warten nur Erstattungen über 100 auf eine Person.
- Hooks
- Eine Datei unter hooks/ mit dem Namen des Agenten läuft um jeden Tool-Aufruf. Sie kann Parameter ändern, Ergebnisse schwärzen oder den Aufruf stoppen.
Entdecke weitere Features
composer SDKAgenten, Tools und Tests in deinem Projekt.GuardrailsEingaben und finale Antworten prüfen.StorageRetrieval und Datenbank hinter den integrierten Tools.ApprovalsEine Person gibt sensible Tool-Aufrufe frei.VerbindungenAgenten aus deinen bestehenden Systemen starten.ObservabilityInputs, Output und Dauer jedes Tool-Aufrufs.
Häufig gestellte Fragen
connic liest jede öffentliche Funktion unter tools/ und in den Unterordnern. Der Funktionsname wird zum Tool-Namen, der Docstring zur Beschreibung, und aus den Type Hints entsteht das JSON Schema der Parameter. Im Agenten trägst du die Funktion als module.function ein, zum Beispiel orders.lookup_order, ganz ohne Decorator.
Mit entfernten Servern, die Streamable HTTP sprechen und für connic erreichbar sind, öffentlich oder über eine connic Bridge. Stdio-Server werden nicht unterstützt. connic lädt die Tools eines Servers, eigenständige Resources und Prompts nutzt es nicht. MCP-Server funktionieren mit LLM-Agenten.
Eigene Tools sind Python-Funktionen. Logik in einer anderen Sprache kann hinter einem MCP-Server oder einer HTTP-API mit OpenAPI Spec liegen. Der Agent ruft diese Tools dann neben seinen Python-Tools auf.
Ja. Füge die Spec in den composer-Einstellungen des Projekts unter API Spec Tools hinzu, als Datei oder URL, mit Bearer Token, API Key oder Basic Auth. Jeder Endpoint wird zu einem Tool, das Agenten über seinen Namen ansprechen, etwa api:my_api.users_get, und eine Wildcard wie api:my_api.* bindet alle ein.
Trag selten genutzte Tools unter discoverable_tools ein oder setz discoverable: true für einen MCP-Server. connic indexiert sie, und der Agent sucht bei Bedarf anhand der Beschreibung danach. Die Suche kostet einen zusätzlichen Modellschritt, deshalb gehören Tools, die ein Agent fast immer braucht, unter tools.
Ja. Das integrierte Tool trigger_agent startet einen anderen Agenten im selben Projekt über seinen Namen und kann auf die Antwort warten. trigger_agent_at plant einen Run nach einer Wartezeit oder zu einem festen Zeitpunkt, bis zu 30 Tage im Voraus.