und Giant Language Fashions (LLMs)
Große Sprachmodelle (LLMs) sind fortschrittliche KI-Systeme, die auf tiefen neuronalen Netzwerken wie Transformatoren basieren und auf riesigen Textmengen trainiert werden, um eine menschenähnliche Sprache zu erzeugen. LLMs wie ChatGPT, Claude, Gemini und Grok können viele anspruchsvolle Aufgaben bewältigen und werden in Bereichen wie Wissenschaft, Gesundheitswesen, Bildung und Finanzen eingesetzt.
Ein KI-Agent erweitert die Fähigkeiten von LLMs, um Aufgaben zu lösen, die über ihr vorab trainiertes Wissen hinausgehen. Ein LLM kann ein Python-Tutorial auf der Grundlage dessen schreiben, was er während der Schulung gelernt hat. Wenn Sie ihn bitten, einen Flug zu buchen, erfordert die Aufgabe Zugriff auf Ihren Kalender, eine Websuche und die Fähigkeit, Maßnahmen zu ergreifen. Dies übersteigt die vorab geschulten Kenntnisse des LLM. Zu den häufigsten Maßnahmen gehören:
- Wettervorhersage: Das LLM stellt eine Verbindung zu einem Websuchtool her, um die neueste Wettervorhersage abzurufen.
- Buchungsagent: Ein KI-Agent, der den Kalender eines Benutzers überprüfen, das Web durchsuchen kann, um eine Buchungsseite wie Expedia zu besuchen, um verfügbare Optionen für Flüge und Motels zu finden, diese dem Benutzer zur Bestätigung vorzulegen und die Buchung im Namen des Benutzers abzuschließen.
So funktioniert ein KI-Agent
KI-Agenten bilden ein System, das ein großes Sprachmodell verwendet, um Schritte zur Interaktion mit seiner Umgebung zu planen, zu begründen und zu unternehmen, indem es Werkzeuge verwendet, die aus der Argumentation des Modells zur Lösung einer bestimmten Aufgabe vorgeschlagen werden.
Grundstruktur eines KI-Agenten
- Ein großes Sprachmodell (LLM): Das LLM ist das Gehirn eines KI-Agenten. Es berücksichtigt die Eingabeaufforderung, Pläne und Gründe des Benutzers durch die Anfrage und unterteilt das Drawback in Schritte, die bestimmen, welche Instruments zur Erledigung der Aufgabe verwendet werden sollen.
- Ein Werkzeug ist das Framework, das der Agent verwendet, um eine Aktion basierend auf dem Plan und den Überlegungen des Giant Language Mannequin auszuführen. Wenn Sie einen LLM bitten, einen Tisch für Sie in einem Restaurant zu reservieren, werden möglicherweise Instruments wie ein Kalender zur Überprüfung Ihrer Verfügbarkeit und ein Websuchtool verwendet, um auf die Web site des Eating places zuzugreifen und eine Reservierung für Sie vorzunehmen.
Illustrierte Entscheidungsfindung eines Buchungs-KI-Agenten
KI-Agenten können je nach Aufgabe auf unterschiedliche Instruments zugreifen. Ein Device kann ein Datenspeicher sein, beispielsweise eine Datenbank. Beispielsweise könnte ein Kundendienstmitarbeiter auf die Kontodetails und die Kaufhistorie eines Kunden zugreifen und entscheiden, wann er diese Informationen abruft, um bei der Lösung eines Issues zu helfen.
KI-Agenten werden zur Lösung vielfältiger Aufgaben eingesetzt und es stehen viele leistungsstarke Agenten zur Verfügung. Codierungsagenten, insbesondere Agenten-IDEs wie Cursor, Windsurf und GitHub Copilot, helfen Ingenieuren, Code schneller zu schreiben und zu debuggen und Projekte schnell zu erstellen. CLI-Codierungsagenten wie Claude Code und Codex CLI können mit dem Desktop und Terminal eines Benutzers interagieren, um Codierungsaufgaben auszuführen. ChatGPT unterstützt Agenten, die im Namen eines Benutzers Aktionen wie die Buchung von Reservierungen durchführen können. Agenten werden auch in Kundensupport-Workflows integriert, um mit Kunden zu kommunizieren und ihre Probleme zu lösen.
Funktionsaufruf
Funktionsaufrufe sind eine Technik zum Verbinden eines großen Sprachmodells (LLM) mit externen Instruments wie APIs oder Datenbanken. Es wird bei der Erstellung von KI-Agenten verwendet, um LLMs mit Instruments zu verbinden. Beim Funktionsaufruf wird jedes Device als Codefunktion (z. B. eine Wetter-API zum Abrufen der neuesten Vorhersage) zusammen mit einem JSON-Schema definiert, das die Parameter der Funktion angibt und den LLM anweist, wann und wie die Funktion für eine bestimmte Aufgabe aufgerufen werden soll.
Der definierte Funktionstyp hängt von der Aufgabe ab, die der Agent ausführen soll. Beispielsweise können wir für einen Kundendienstmitarbeiter eine Funktion definieren, die Informationen aus unstrukturierten Daten extrahieren kann, beispielsweise PDFs mit Particulars zu den Produkten eines Unternehmens.
In diesem Beitrag werde ich zeigen, wie man Funktionsaufrufe verwendet, um einen einfachen Websuchagenten mit GPT-5 als großem Sprachmodell zu erstellen.
Grundstruktur eines Internet-Suchagenten
Die Hauptlogik hinter dem Internet-Suchagenten:
- Definieren Sie eine Codefunktion für die Websuche.
- Definieren Sie benutzerdefinierte Anweisungen, die das große Sprachmodell dabei unterstützen, anhand der Abfrage zu bestimmen, wann die Websuchfunktion aufgerufen werden soll. Wenn die Abfrage beispielsweise nach dem aktuellen Wetter fragt, erkennt der Internet-Suchagent die Notwendigkeit, im Web nach den neuesten Wetterberichten zu suchen. Wenn die Abfrage jedoch dazu auffordert, ein Tutorial über eine Programmiersprache wie Python zu schreiben, auf das sie aufgrund ihres vorab trainierten Wissens antworten kann, ruft sie nicht die Websuchfunktion auf, sondern antwortet stattdessen direkt.
Voraussetzung
Erstellen Sie ein OpenAI-Konto und generieren Sie einen API-Schlüssel
1: Erstellen Sie eine OpenAI-Konto falls du keins hast
2: Generieren Sie einen API-Schlüssel
Umgebung einrichten und aktivieren
python3 -m venv env
supply env/bin/activateOpenAI-API-Schlüssel exportieren
export OPENAI_API_KEY="Your Openai API Key"Richten Sie Tavily für die Websuche ein
Tavily ist ein spezialisiertes Websuchtool für KI-Agenten. Erstellen Sie ein Konto unter Tavily.comund sobald Ihr Profil eingerichtet ist, wird ein API-Schlüssel generiert, den Sie in Ihre Umgebung kopieren können. Neue Konten erhalten 1.000 kostenlose Credit, die für bis zu 1.000 Websuchen verwendet werden können.
Exportieren Sie den TAVILY-API-Schlüssel
export TAVILY_API_KEY="Your Tavily API Key"Pakete installieren
pip3 set up openai
pip3 set up tavily-pythonErstellen eines Internet-Suchagenten mit Funktionsaufruf Schritt für Schritt
Schritt 1: Erstellen Sie eine Websuchfunktion mit Tavily
Mithilfe von Tavily wird eine Websuchfunktion implementiert, die als Werkzeug für den Funktionsaufruf im Websuchagenten dient.
from tavily import TavilyClient
import os
tavily = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
def web_search(question: str, num_results: int = 10):
attempt:
consequence = tavily.search(
question=question,
search_depth="primary",
max_results=num_results,
include_answer=False,
include_raw_content=False,
include_images=False
)
outcomes = consequence.get("outcomes", ())
return {
"question": question,
"outcomes": outcomes,
"sources": (
{"title": r.get("title", ""), "url": r.get("url", "")}
for r in outcomes
)
}
besides Exception as e:
return {
"error": f"Search error: {e}",
"question": question,
"outcomes": (),
"sources": (),
}Aufschlüsselung des Webfunktionscodes
Tavily wird mit seinem API-Schlüssel initialisiert. Im web_search Funktion werden folgende Schritte ausgeführt:
- Die Tavily-Suchfunktion wird aufgerufen, um das Web zu durchsuchen und die High-10-Ergebnisse abzurufen.
- Die Suchergebnisse und die entsprechenden Quellen werden zurückgegeben.
Diese zurückgegebene Ausgabe dient als relevanter Kontext für den Websuchagenten, den wir später in diesem Artikel definieren werden, um aktuelle Informationen für Abfragen (Eingabeaufforderungen) abzurufen, die Echtzeitdaten wie Wettervorhersagen erfordern.
Schritt 2: Toolschema erstellen
Das Device-Schema definiert benutzerdefinierte Anweisungen für ein KI-Modell, wann es ein Device aufrufen soll, in diesem Fall das Device, das in einer Websuchfunktion verwendet wird. Außerdem werden die Bedingungen und Aktionen angegeben, die ausgeführt werden müssen, wenn das Modell ein Device aufruft. Nachfolgend wird ein JSON-Device-Schema basierend auf definiert Schemastruktur des OpenAI-Instruments.
tool_schema = (
{
"sort": "perform",
"title": "web_search",
"description": """Execute an internet search to fetch updated info. Synthesize a concise,
self-contained reply from the content material of the outcomes of the visited pages.
Fetch pages, extract textual content, and supply the most effective obtainable consequence whereas citing 1-3 sources (title + URL).
If sources battle, floor the uncertainty and like the latest proof.
""",
"strict": True,
"parameters": {
"sort": "object",
"properties": {
"question": {
"sort": "string",
"description": "Question to be searched on the net.",
},
},
"required": ("question"),
"additionalProperties": False
},
},
)
Eigenschaften des Werkzeugschemas
- Typ: Gibt an, dass der Werkzeugtyp eine Funktion ist.
- Identify: Der Identify der Funktion, die für den Werkzeugaufruf verwendet wird web_search.
- Beschreibung: Beschreibt, was das KI-Modell tun soll, wenn es das Websuchtool aufruft. Es weist das Modell an, das Web mit dem zu durchsuchen web_search Funktion zum Abrufen aktueller Informationen und zum Extrahieren relevanter Particulars, um die beste Antwort zu generieren.
- strikt: Wenn diese Eigenschaft auf „true“ gesetzt ist, weist sie den LLM an, die Anweisungen des Toolschemas strikt zu befolgen.
- Parameter: Definiert die Parameter, die an übergeben werden web_search Funktion. In diesem Fall gibt es nur einen Parameter: Abfrage Dies stellt den Suchbegriff dar, nach dem im Web gesucht werden soll.
- erforderlich: Weist den LLM an, dass die Abfrage ein obligatorischer Parameter für ist web_search Funktion.
- zusätzlicheEigenschaften: Es ist auf „false“ gesetzt, was bedeutet, dass das Device Argumente Objekt darf keine anderen als die unter definierten Parameter enthalten Parameter.Eigenschaften.
Schritt 3: Erstellen Sie den Internet-Suchagenten mit GPT-5 und Funktionsaufrufen
Schließlich werde ich einen Agenten erstellen, mit dem wir chatten können und der das Web durchsuchen kann, wenn er aktuelle Informationen benötigt. Ich werde es verwenden GPT-5-miniein schnelles und genaues Modell von OpenAI, zusammen mit Funktionsaufrufen zum Aufrufen von Werkzeugschema und die Internet-Suchfunktion bereits definiert.
from datetime import datetime, timezone
import json
from openai import OpenAI
import os
consumer = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# tracker for the final mannequin's response id to take care of dialog's state
prev_response_id = None
# a listing for storing device's outcomes from the perform name
tool_results = ()
whereas True:
# if the device outcomes is empty immediate message
if len(tool_results) == 0:
user_message = enter("Person: ")
""" instructions for exiting chat """
if isinstance(user_message, str) and user_message.strip().decrease() in {"exit", "q"}:
print("Exiting chat. Goodbye!")
break
else:
user_message = tool_results.copy()
# clear the device outcomes for the subsequent name
tool_results = ()
# receive present's date to be handed into the mannequin as an instruction to help in choice making
today_date = datetime.now(timezone.utc).date().isoformat()
response = consumer.responses.create(
mannequin = "gpt-5-mini",
enter = user_message,
directions=f"Present date is {today_date}.",
instruments = tool_schema,
previous_response_id=prev_response_id,
textual content = {"verbosity": "low"},
reasoning={
"effort": "low",
},
retailer=True,
)
prev_response_id = response.id
# Handles mannequin response's output
for output in response.output:
if output.sort == "reasoning":
print("Assistant: ","Reasoning ....")
for reasoning_summary in output.abstract:
print("Assistant: ",reasoning_summary)
elif output.sort == "message":
for merchandise in output.content material:
print("Assistant: ",merchandise.textual content)
elif output.sort == "function_call":
# receive perform title
function_name = globals().get(output.title)
# hundreds perform arguments
args = json.hundreds(output.arguments)
function_response = function_name(**args)
tool_results.append(
{
"sort": "function_call_output",
"call_id": output.call_id,
"output": json.dumps(function_response)
}
)Schritt-für-Schritt-Codeaufschlüsselung
from openai import OpenAI
import os
consumer = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
prev_response_id = None
tool_results = ()- Initialisierte die OpenAI-Modell-API mit einem API-Schlüssel.
- Zwei Variablen initialisiert prev_response_id Und tool_results. prev_response_id Verfolgt die Reaktion des Modells, um den Gesprächsstatus aufrechtzuerhalten, und tool_results ist eine Liste, die die von zurückgegebenen Ausgaben speichert web_search Funktionsaufruf.
Der Chat läuft innerhalb des Schleife. Ein Benutzer gibt eine Nachricht ein und das mit dem Device-Schema aufgerufene Modell akzeptiert die Nachricht, begründet sie, entscheidet, ob das Websuchtool aufgerufen werden soll, und dann wird die Ausgabe des Instruments an das Modell zurückgegeben. Das Modell generiert eine kontextbezogene Antwort. Dies wird so lange fortgesetzt, bis der Benutzer den Chat verlässt.
Code-Komplettlösung der Schleife
if len(tool_results) == 0:
user_message = enter("Person: ")
if isinstance(user_message, str) and user_message.strip().decrease() in {"exit", "q"}:
print("Exiting chat. Goodbye!")
break
else:
user_message = tool_results.copy()
tool_results = ()
today_date = datetime.now(timezone.utc).date().isoformat()
response = consumer.responses.create(
mannequin = "gpt-5-mini",
enter = user_message,
directions=f"Present date is {today_date}.",
instruments = tool_schema,
previous_response_id=prev_response_id,
textual content = {"verbosity": "low"},
reasoning={
"effort": "low",
},
retailer=True,
)
prev_response_id = response.id- Überprüft, ob die tool_results ist leer. Wenn dies der Fall ist, wird der Benutzer aufgefordert, eine Nachricht einzugeben, mit der Choice, die Verwendung zu beenden Ausfahrt oder Q.
- Wenn die tool_results ist nicht leer, user_message wird auf die gesammelten Werkzeugausgaben eingestellt, die an das Modell gesendet werden sollen. tool_results wird gelöscht, um ein erneutes Senden desselben zu vermeiden Werkzeugausgänge bei der nächsten Schleifeniteration.
- Das aktuelle Datum (today_date) wird erhalten, damit das Modell zeitbewusste Entscheidungen treffen kann.
- Anrufe consumer.responses.create um die Antwort des Modells zu generieren und akzeptiert die folgenden Parameter:
- Modell: eingestellt auf gpt-5-mini.
- Eingabe: akzeptiert die Nachricht des Benutzers.
- Anleitung: Auf das aktuelle Datum (today_date) setzen.
- instruments: wird auf das zuvor definierte Device-Schema festgelegt.
- previous_response_id: Wird auf die ID der vorherigen Antwort gesetzt, damit das Modell den Konversationsstatus beibehalten kann.
- Textual content: Die Ausführlichkeit ist auf niedrig eingestellt, um die Antwort des Modells prägnant zu halten.
- Argumentation: GPT-5-mini ist ein Argumentationsmodell. Stellen Sie den Argumentationsaufwand auf niedrig ein, um eine schnellere Reaktion zu erzielen. Für komplexere Aufgaben können wir ihn auf hoch einstellen.
- Retailer: Weist das Modell an, die aktuelle Antwort zu speichern, damit sie später abgerufen werden kann, und hilft bei der Konversationskontinuität.
- prev_response_id
for output in response.output:
if output.sort == "reasoning":
print("Assistant: ","Reasoning ....")
for reasoning_summary in output.abstract:
print("Assistant: ",reasoning_summary)
elif output.sort == "message":
for merchandise in output.content material:
print("Assistant: ",merchandise.textual content)
elif output.sort == "function_call":
# receive perform title
function_name = globals().get(output.title)
# hundreds perform arguments
args = json.hundreds(output.arguments)
function_response = function_name(**args)
# append device outcomes checklist with the the perform name's id and performance's response
tool_results.append(
{
"sort": "function_call_output",
"call_id": output.call_id,
"output": json.dumps(function_response)
}
)Dadurch wird die Antwortausgabe des Modells verarbeitet und Folgendes ausgeführt:
- Wenn der Ausgabetyp „Begründung“ ist, drucken Sie jedes Factor in der Begründungszusammenfassung aus.
- Wenn der Ausgabetyp „Nachricht“ ist, durchlaufen Sie den Inhalt und drucken Sie jedes Textelement aus.
- Wenn der Ausgabetyp ein Funktionsaufruf ist, rufen Sie den Namen der Funktion ab, analysieren Sie ihre Argumente und übergeben Sie sie an die Funktion (web_search), um eine Antwort zu generieren. In diesem Fall enthält die Websuchantwort aktuelle Informationen, die für die Nachricht des Benutzers related sind. Hängt schließlich die Antwort und die Funktionsaufruf-ID des Funktionsaufrufs an tool_results. Dadurch kann die nächste Schleife das Werkzeugergebnis zurück an das Modell senden.
Vollständiger Code für den Internet Search Agent
from datetime import datetime, timezone
import json
from openai import OpenAI
import os
from tavily import TavilyClient
tavily = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
def web_search(question: str, num_results: int = 10):
attempt:
consequence = tavily.search(
question=question,
search_depth="primary",
max_results=num_results,
include_answer=False,
include_raw_content=False,
include_images=False
)
outcomes = consequence.get("outcomes", ())
return {
"question": question,
"outcomes": outcomes,
"sources": (
{"title": r.get("title", ""), "url": r.get("url", "")}
for r in outcomes
)
}
besides Exception as e:
return {
"error": f"Search error: {e}",
"question": question,
"outcomes": (),
"sources": (),
}
tool_schema = (
{
"sort": "perform",
"title": "web_search",
"description": """Execute an internet search to fetch updated info. Synthesize a concise,
self-contained reply from the content material of the outcomes of the visited pages.
Fetch pages, extract textual content, and supply the most effective obtainable consequence whereas citing 1-3 sources (title + URL). "
If sources battle, floor the uncertainty and like the latest proof.
""",
"strict": True,
"parameters": {
"sort": "object",
"properties": {
"question": {
"sort": "string",
"description": "Question to be searched on the net.",
},
},
"required": ("question"),
"additionalProperties": False
},
},
)
consumer = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# tracker for the final mannequin's response id to take care of dialog's state
prev_response_id = None
# a listing for storing device's outcomes from the perform name
tool_results = ()
whereas True:
# if the device outcomes is empty immediate message
if len(tool_results) == 0:
user_message = enter("Person: ")
""" instructions for exiting chat """
if isinstance(user_message, str) and user_message.strip().decrease() in {"exit", "q"}:
print("Exiting chat. Goodbye!")
break
else:
# set the person's messages to the device outcomes to be despatched to the mannequin
user_message = tool_results.copy()
# clear the device outcomes for the subsequent name
tool_results = ()
# receive present's date to be handed into the mannequin as an instruction to help in choice making
today_date = datetime.now(timezone.utc).date().isoformat()
response = consumer.responses.create(
mannequin = "gpt-5-mini",
enter = user_message,
directions=f"Present date is {today_date}.",
instruments = tool_schema,
previous_response_id=prev_response_id,
textual content = {"verbosity": "low"},
reasoning={
"effort": "low",
},
retailer=True,
)
prev_response_id = response.id
# Handles mannequin response's output
for output in response.output:
if output.sort == "reasoning":
print("Assistant: ","Reasoning ....")
for reasoning_summary in output.abstract:
print("Assistant: ",reasoning_summary)
elif output.sort == "message":
for merchandise in output.content material:
print("Assistant: ",merchandise.textual content)
# checks if the output sort is a perform name and append the perform name's outcomes to the device outcomes checklist
elif output.sort == "function_call":
# receive perform title
function_name = globals().get(output.title)
# hundreds perform arguments
args = json.hundreds(output.arguments)
function_response = function_name(**args)
# append device outcomes checklist with the the perform name's id and performance's response
tool_results.append(
{
"sort": "function_call_output",
"call_id": output.call_id,
"output": json.dumps(function_response)
}
)Wenn Sie den Code ausführen, können Sie problemlos mit dem Agenten chatten, um Fragen zu stellen, die die neuesten Informationen erfordern, z. B. das aktuelle Wetter oder die neuesten Produktveröffentlichungen. Der Agent antwortet mit aktuellen Informationen und den entsprechenden Quellen aus dem Web. Unten finden Sie eine Beispielausgabe des Terminals.
Person: What's the climate like in London at the moment?
Assistant: Reasoning ....
Assistant: Reasoning ....
Assistant: Proper now in London: overcast, about 18°C (64°F), humidity ~88%, gentle SW wind ~16 km/h, no precipitation reported. Supply: WeatherAPI (present circumstances) — https://www.weatherapi.com/
Person: What's the newest iPhone mannequin?
Assistant: Reasoning ....
Assistant: Reasoning ....
Assistant: The most recent iPhone fashions are the iPhone 17 lineup (together with iPhone 17, iPhone 17 Professional, iPhone 17 Professional Max) and the brand new iPhone Air — introduced by Apple on Sept 9, 2025. Supply: Apple Newsroom — https://www.apple.com/newsroom/2025/09/apple-debuts-iphone-17/
Person: Multiply 500 by 12.
Assistant: Reasoning ....
Assistant: 6000
Person: exit
Exiting chat. Goodbye!Sie können die Ergebnisse mit den entsprechenden Webquellen sehen. Wenn Sie ihn bitten, eine Aufgabe auszuführen, für die keine aktuellen Informationen erforderlich sind, beispielsweise mathematische Berechnungen oder das Schreiben von Code, antwortet der Agent direkt und ohne Websuche.
Hinweis: Der Internet-Suchagent ist ein einfacher Einzeltool-Agent. Fortschrittliche Agentensysteme orchestrieren mehrere spezialisierte Instruments und nutzen effizienten Speicher, um den Kontext beizubehalten, zu planen und komplexere Aufgaben zu lösen.
Abschluss
In diesem Beitrag habe ich erklärt, wie ein KI-Agent funktioniert und wie er die Fähigkeiten eines großen Sprachmodells erweitert, um mit seiner Umgebung zu interagieren, Aktionen auszuführen und Aufgaben mithilfe von Instruments zu lösen. Ich habe auch den Funktionsaufruf erklärt und wie er es LLMs ermöglicht, Instruments aufzurufen. Ich habe gezeigt, wie man ein Device-Schema für Funktionsaufrufe erstellt, das definiert, wann und wie ein LLM ein Device aufrufen soll, um eine Aktion auszuführen. Ich habe mit Tavily eine Websuchfunktion definiert, um Informationen aus dem Internet abzurufen, und dann Schritt für Schritt gezeigt, wie man mithilfe von Funktionsaufrufen und GPT-5-mini als LLM einen Websuchagenten erstellt. Am Ende haben wir einen Internet-Suchagenten entwickelt, der in der Lage ist, aktuelle Informationen aus dem Web abzurufen, um Benutzeranfragen zu beantworten.
Schauen Sie sich mein GitHub-Repo an, GenAI-Kurse wo ich weitere Kurse zu verschiedenen Themen der generativen KI veröffentlicht habe. Es enthält auch eine Anleitung zum Bau eines Agentischer RAG mit Funktionsaufruf.
Kontaktieren Sie mich über:
E-Mail: (e-mail protected)
Linkedin: https://www.linkedin.com/in/ayoola-olafenwa-003b901a9/
Referenzen
https://platform.openai.com/docs/guides/function-calling?api-mode=responses
https://docs.tavily.com/documentation/api-reference/endpoint/search