Verschiedene KI-Unternehmen führen jetzt agentische KI-Systeme ein, die tiefgehende Recherchen zu Ihrem gewünschten Thema durchführen und einen umfassenden Bericht erstellen können – wie zum Beispiel Deep Research von OpenAI.
Agentische KI-Systeme wie OpenAIs Deep Research bieten automatisierte Pipelines für komplexe Aufgaben wie mehrstufige Suche und Synthese. Die meisten bestehenden Lösungen sind jedoch quellgeschlossen, schwer anpassbar und schränken Ihre Kontrolle über das Modellverhalten und die Datenverarbeitung ein.
Beispielsweise möchten Sie vielleicht ein anderes LLM verwenden, einen benutzerdefinierten Suchanbieter oder die Art und Weise anpassen, wie Agenten planen und sich verhalten, um bestimmte Ergebnisse zu erzielen.
Das führt zu einer interessanten Frage: Können Sie Ihren eigenen Deep-Search-Agenten mit voller Flexibilität erstellen, bei dem Sie Ihr bevorzugtes KI-Modell verwenden, Ihre bevorzugte Suchmaschine integrieren und das Verhalten des Agenten anpassen können? Die Antwort ist ja.
In diesem Artikel erfahren Sie, wie Sie Ihren eigenen Deep-Research-Agenten mit Novita AI, LangChain und Tavily erstellen.
Was ist ein Deep-Search-Agenten-Workflow?
Traditionelle Suche ist oft zeitaufwändig, da sie in der Regel das Durchforsten einer Menge online verfügbarer Informationen beinhaltet und am Ende möglicherweise nicht zu Erkenntnissen führt. Ein Deep-Search-Agenten-Workflow löst diese Probleme durch KI-Agenten, die autonom denken, Entscheidungen treffen und externe Tools als Teil eines Workflows koordinieren können.
Dieser Workflow umfasst normalerweise:
-
Aufgabenstrukturierung: Der KI-Agent zerlegt das Thema in kleinere Aufgaben.
-
Planung: Der Agent erstellt Strategien zur Bearbeitung jeder Aufgabe, was dem Workflow hilft, die Reihenfolge der Aufgabenausführung zu bestimmen.
-
Tool-Integration: Um Informationen zu sammeln, verwendet der Agent verschiedene Tools wie Datenbanken und Websuchmaschinen. Ohne diese Tools kann der Agent keine Schlüsselaktionen im Workflow ausführen.
-
Synthese: Der Agent analysiert die gesammelten Informationen und kombiniert sie zu kohärenten Daten.
-
Berichtserstellung: Nach der Synthese der Daten erstellt der Agent einen strukturierten Bericht mit Zusammenfassungen und Quellenangaben.
Benötigte Werkzeuge
Bevor wir mit dem Bau des Workflows beginnen, richten wir die notwendigen Tools ein.
Novita AI
Um den agentischen Workflow zu erstellen, benötigen wir ein LLM. Novita AI bietet eine erschwingliche, leistungsstarke API, die Ihnen Zugang zu den neuesten LLMs, Bildgenerierungsmodellen und mehr bietet.
Melden Sie sich bei Novita AI an, um loszulegen. Navigieren Sie nach dem Login zu Einstellungen > Schlüsselverwaltung und folgen Sie den Anweisungen, um einen API-Schlüssel zu generieren.
Beachten Sie, dass Novita AI Ihnen nach der Registrierung kostenlose Credits bietet, um verschiedene Modelle auszuprobieren. Sie müssen sich also keine Sorgen über den Kauf von Credits machen, bevor Sie mit dem Bau oder Experimentieren beginnen.
Tavily
Tavily ist eine erweiterte Websuch-API, die für KI-Anwendungen optimiert ist. Mit dem Suchmaschinen-Tool von Tavily können wir unserem Agenten Zugriff auf das Internet geben, um genaue und unvoreingenommene Informationen zu sammeln. Gehen Sie zu Tavily und generieren Sie einen API-Schlüssel.
LangChain
LangChain ist ein Open-Source-Framework, das für die Erstellung von Anwendungen mit LLMs entwickelt wurde. Mit LangChain können Sie einen agentischen Workflow erstellen, der schrittweise denkt, Tools verwendet und mit APIs interagiert. Für unseren Deep-Research-Agenten werden wir LangChain verwenden, um den Forschungsprozess zu strukturieren, Tools wie die Websuche zu nutzen und alles in einen strukturierten Bericht zu synthetisieren.
Google Colab
In diesem Tutorial werden wir den Deep-Search-Agenten mit Google Colab erstellen und testen. Colab ermöglicht es Ihnen, Python-Code im Browser zu schreiben und auszuführen, ohne dass eine Einrichtung erforderlich ist. Dadurch ist das Tutorial einfach nachvollziehbar.
Workflow-Übersicht
Der Deep Agentic Search ist eine Kombination verschiedener Workflow-Phasen, von der Planung der Suchaufgabe bis zur Auslieferung des endgültigen Suchberichts. Lassen Sie uns jeden Schritt des Workflows durchgehen, um zu verstehen, wie die App funktioniert.
Recherche-Planung
Dies ist der erste Schritt des Workflows. Hier analysiert der Agent das Thema und erstellt einen strukturierten Forschungsplan basierend auf dem Kontext des Themas. Er zerlegt das breite Thema in gezielte Unterthemen wie Geschichte, technische Details, Vor- und Nachteile, Anwendungsfälle und mehr.
Sie können dies als den wichtigsten Teil des Workflows betrachten, denn ohne ihn könnte der Agent generische Suchen durchführen und irrelevante Ergebnisse liefern.
Tiefgehende Suche
LLMs sind auf ihre Trainingsdaten beschränkt und haben keinen Zugriff auf aktuelle Trends. Wenn Sie den Agenten ohne Suchfunktion bitten, die aktuellen Spieler einer Fußballmannschaft aufzulisten, wird er Ergebnisse basierend auf den Daten liefern, mit denen er trainiert wurde. Da diese Ergebnisse jedoch keine aktuellen Aktualisierungen enthalten, könnten sie sachlich nicht mehr korrekt sein.
Die Verwendung von Tavily zur Durchführung erweiterter Websuchen gibt dem Agenten Zugriff auf die aktuellsten und relevantesten Webquellen.
Quellenverwaltung
Um sicherzustellen, dass jede vom Agenten produzierte Information mit einer zuverlässigen Quelle verknüpft werden kann, ist es wichtig, alle Quellen nachzuverfolgen. Dieser Teil des Workflows schafft Vertrauen bei Benutzern, die Behauptungen oder Daten im endgültigen Bericht überprüfen möchten.
Synthese
Um die Verbindungen zwischen allen gesammelten Informationen herzustellen, bringt der Agent Erkenntnisse aus allen recherchierten Aspekten zusammen, um einen kohärenten Bericht zu erstellen. Ohne diese Phase des Workflows wäre das Suchergebnis möglicherweise nur ein zusammenhangloser Bericht.
Endgültige Formatierung
Selbst wenn der Bericht sachlich korrekt und gut recherchiert ist, kann eine schlechte Formatierung das Lesen erschweren. Ein zusätzlicher Schritt ist erforderlich, um eine saubere Struktur, konsistente Überschriften, Aufzählungspunkte, Abstände und mehr sicherzustellen.
Implementierung des Deep-Search-Agenten
Bisher haben Sie verstanden, worum es beim Deep-Search-Agenten-Workflow geht. Jetzt ist es an der Zeit, ihn in Google Colab zu implementieren.
Um zu beginnen, führen wir einige wichtige Schritte aus:
Schritt 1: Abhängigkeiten installieren
-q langchain langchain-openai tavily-python
Schritt 2: Notwendige Bibliotheken importieren
# Import standard Python libraries
import os # For interacting with environment variables
import re # For regular expression
import ast # For safely parsing Python expressions from strings
# LangChain models and tools
from langchain_openai import ChatOpenAI # Interface for interacting with OpenAI's chat models
from langchain_community.utilities.tavily_search import TavilySearchAPIWrapper # Enables search via the Tavily API
# LangChain message schema
from langchain.schema import SystemMessage, HumanMessage # Defines message types used in conversations
# LangChain agent components
from langchain.agents import Tool, AgentExecutor, create_react_agent # For building and running agentic workflows with tools
# LangChain prompt templates
from langchain.prompts import PromptTemplate # Allows creation of reusable prompt templates
# LangChain memory
from langchain.memory import ConversationBufferMemory # Helps maintain conversation state across turns
Schritt 3: Umgebungsvariablen einrichten
# Setting and retrieving environment variables
os.environ["NOVITA_API_KEY"] = "" # Replace with your actual Novita API key
os.environ["TAVILY_API_KEY"] = "" # Replace with your actual Tavily API key
# Load the API keys into variables
novita_api_key = os.getenv("NOVITA_API_KEY")
tavily_api_key = os.getenv("TAVILY_API_KEY")
Schritt 4: Eine LLM-Hilfsfunktion definieren
Novita AI ist kompatibel mit OpenAI; daher werden wir das ChatOpenAI-Modul von LangChain verwenden, um Novita AI mit LangChain zu integrieren. Das bedeutet, dass wir mit Novita auf die gleiche Weise kommunizieren können wie mit OpenAI-Modellen.
Ein wichtiger Punkt ist jedoch, dass wir die base_url auf den API-Endpunkt von Novita setzen müssen: https://api.novita.ai/v3/openai.
In diesem Workflow verwenden wir das Modell llama-4-maverick-17b-128e-instruct-fp8, eine leistungsstarke LLaMA-4-Variante, die für Aufgaben zur Anweisungsbefolgung optimiert ist.
# LLM helper function
def llm(api_key,
model="meta-llama/llama-4-maverick-17b-128e-instruct-fp8",
temperature=0.7):
"""Create a ChatOpenAI LLM instance with specified parameters."""
return ChatOpenAI(
model=model,
openai_api_key=api_key,
base_url="https://api.novita.ai/v3/openai",
temperature=temperature,
)
Erstellung des Agentic Researcher
Der gesamte Deep-Research-Workflow ist in einer modularen Klasse namens AgenticResearcher gekapselt. Diese Klasse wird den Prozess der Erstellung von Forschungsplänen, der Durchführung von Websuchen, der Synthese von Ergebnissen, der Formatierung des endgültigen Berichts und der Ausführung der vollständigen Forschungsschleife verwalten.
Wir initialisieren den Forschungsagenten mit Zugriff auf ein LLM über die Novita-API und ein Websuch-Tool über die Tavily-API. Dann definieren wir eine Methode, die eine erweiterte Websuche zu einer bestimmten Abfrage mit Tavily durchführt. Die Ergebnisse werden für die Lesbarkeit formatiert und die Rohdaten für die spätere Verwendung gespeichert.
class AgenticResearcher:
def __init__(self, novita_api_key, tavily_api_key, num_researchers=3, temperature=0.3):
"""Initialize the research agent with necessary API keys and parameters."""
self.llm = llm(api_key=novita_api_key, temperature=temperature)
self.tavily_search =
TavilySearchAPIWrapper(tavily_api_key=tavily_api_key)
self.num_researchers = num_researchers
self.raw_search_results = []
def search(self, query):
"""Search the web for information on a given query."""
try:
results = self.tavily_search.results(
query, max_results=7,
search_depth="advanced"
)
# Store raw results for citation processing
self.raw_search_results.extend(results)
formatted = []
for r in results:
formatted += [
f"TITLE: {r.get('title','')}",
f"URL: {r.get('url','')}",
f"CONTENT:\
{r.get('content','')}",
"---"
]
return "\
".join(formatted) if formatted else "No results found"
except Exception as e:
return f"Search error: {str(e)}"
Erstellung von Multi-Aspekt-Forschungsplänen
Immer noch Teil der AgenticResearcher-Klasse, erstellen wir eine Methode, die einen strukturierten Forschungsplan generiert, indem sie das Thema mithilfe des LLMs in mehrere unterschiedliche Aspekte aufteilt. Jeder Aspekt enthält einen Titel und eine spezifische Suchanfrage. Ziel ist es, das Thema aus mehreren Blickwinkeln zu erkunden, um sowohl Tiefe als auch Breite zu gewährleisten.
def create_research_plan(self, topic):
"""Create a structured research plan with multiple aspects to investigate."""
sys = "You are a planner that outputs Python lists of dicts."
hum = f"""
Create a comprehensive research plan for: {topic}
Identify {self.num_researchers} distinct aspects to investigate thoroughly.
Analyze the topic and determine the most relevant aspects to research based on its nature and domain.
Output exactly:
ASPECT {{'title': '...', 'search_query': '...'}}
"""
try:
resp = self.llm.invoke([SystemMessage(content=sys), HumanMessage(content=hum)])
aspects = []
for line in resp.content.splitlines():
if line.strip().startswith("ASPECT"):
m = re.search(r"\{.*\}", line)
if m:
try:
aspects.append(ast.literal_eval(m.group(0)))
except Exception as e:
print(f"Error parsing aspect: {e}")
if not aspects:
# General-purpose default aspects that work across different domains
default_aspects = [
{"title": "Overview and Key Information", "search_query": f"{topic} overview key facts"},
{"title": "Background and Context", "search_query": f"{topic} background history context"},
{"title": "Details and Specifications", "search_query": f"{topic} details specifics data"},
{"title": "Analysis and Significance", "search_query": f"{topic} analysis importance implications"}
]
aspects = default_aspects[:self.num_researchers]
return aspects
except Exception as e:
print(f"Error creating research plan: {e}")
return [{"title": f"{topic} research", "search_query": topic}]
Quellenverwaltung und Zitierung
Als nächstes müssen wir handhaben, wie der Workflow glaubwürdige Berichte erstellt. Dazu erstellen wir eine Methode, die eindeutige Quellen aus den rohen Suchergebnissen extrahiert und sicherstellt, dass jede Quelle zitiert wird.
def extract_sources(self):
"""Extract unique sources from raw search results for citations."""
unique_sources = {}
for result in self.raw_search_results:
url = result.get('url', '')
if url and 'http' in url:
domain = url.split('/')[2] if len(url.split('/')) > 2 else url
if domain not in unique_sources:
unique_sources[domain] = url
return unique_sources
Berichtssynthese
Nachdem wir rohe Informationen aus mehreren Quellen gesammelt haben, besteht der nächste Schritt darin, diese unstrukturierten Eingaben in einen detaillierten Forschungsbericht umzuwandeln. Wir schreiben Methoden, die den Rohtext in einen lesbaren, organisierten Bericht mit Überschriften, Unterüberschriften, wichtigsten Erkenntnissen und Quellenangaben synthetisieren.
def synthesize(self, text):
"""Synthesize raw text into detailed, structured findings with citations."""
sources = self.extract_sources()
sources_list = list(sources.keys())
sys = """You are an expert research synthesizer that creates detailed, structured reports.
For each claim or fact you include, add a citation to the source domain.
Use the exact domain names provided without modification.
Adapt your report structure to the topic's domain and nature."""
hum = f"""
INFORMATION TO SYNTHESIZE:
{text}
AVAILABLE SOURCE DOMAINS (use these exact names for citations):
{sources_list}
Create a comprehensive, detailed research report with:
1. Main findings with specific facts and figures
2. Structured information with clear headings and subheadings appropriate to the topic
3. Citations using the exact source domain names in square brackets [like.this]
4. Relevant data presented clearly and professionally
5. Format adapted to the specific nature of the topic (technical, historical, news event, etc.)
FORMAT THE REPORT PROFESSIONALLY AND THOROUGHLY WITHOUT ASSUMING ANY SPECIFIC DOMAIN.
"""
try:
return self.llm.invoke([SystemMessage(content=sys), HumanMessage(content=hum)]).content
except Exception as e:
return f"Synthesis error: {str(e)}"
Erstellung von Tools für den Agenten
Damit unser Deep-Search-Agenten-Workflow funktionsfähig ist, müssen wir die Tools definieren. Tools geben dem Agenten die Fähigkeit, bestimmte Aktionen auszuführen.
Die Kerntools, die für diesen Workflow benötigt werden, sind „plan“, um den Agenten beim Zerlegen des Themas und Erstellen eines strukturierten Forschungsplans zu unterstützen, „search“, um dem Agenten eine tiefgehende Websuche zu ermöglichen, und „synthesize“, um dem Agenten zu erlauben, alle rohen Erkenntnisse in einen organisierten Bericht umzuwandeln.
def get_tools(self):
"""Create and return the list of tools available to the agent."""
return [
Tool(
name="plan",
func=lambda t: str(self.create_research_plan(t)),
description="Create a detailed research plan with multiple aspects to investigate."
),
Tool(
name="search",
func=self.search,
description="Search the web thoroughly for a query and return comprehensive results."
),
Tool(
name="synthesize",
func=self.synthesize,
description="Transform raw text into detailed, structured findings with citations."
),
]
Erstellung des Agent Executors
Nachdem unsere Tools bereit sind, müssen wir alles mit einem ReAct-Prompting-Stil zu einem KI-Agenten zusammenführen. Dies hilft dem Agenten, zu planen, Aktionen mit den definierten Tools durchzuführen, die Ergebnisse zu beobachten und zu wiederholen, bis er genügend Daten hat, um einen endgültigen Forschungsbericht zu erstellen.
def get_agent_executor(self):
"""Create and return the agent executor with tools and memory."""
tools = self.get_tools()
template = """You are an autonomous research agent specialized in producing comprehensive, detailed reports on any topic.
{tool_names}
TOOLS:
{tools}
PREVIOUS CONVERSATIONS:
{chat_history}
When given a research topic (as {input}), follow this process:
1. Analyze the type of topic and create a research plan tailored to its domain
2. Search for comprehensive information on each aspect of the topic
3. Collect detailed, relevant information with sources
4. Synthesize everything into a professional, detailed report formatted appropriately for the topic
Follow exactly this format:
Question: {input}
Thought: (your reasoning here)
Action: the name of the tool to call, must be one of [{tool_names}]
Action Input: the input to the tool
Observation: (the tool's output)
... (repeat Thought/Action/Action Input/Observation as needed)
When you have gathered comprehensive information, output:
Final Answer: (your final, detailed research report with structured sections, appropriate formatting, specific details, and citations)
BEGIN WITH A THOROUGH PLAN!
{agent_scratchpad}
"""
prompt = PromptTemplate(
template=template,
input_variables=["input", "agent_scratchpad", "tools", "tool_names", "chat_history"]
)
# Create the low-level agent
agent = create_react_agent(
llm=self.llm,
tools=tools,
prompt=prompt
)
# Wrap it in an executor with memory
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
agent_executor = AgentExecutor.from_agent_and_tools(
agent=agent,
tools=tools,
verbose=True,
memory=memory,
max_iterations=18,
early_stopping_method="generate",
handle_parsing_errors=True
)
return agent_executor
Endgültige Berichtsformatierung
Nachdem der Forschungsagent seine tiefgehende Suche abgeschlossen hat, kann die Ausgabe informativ, aber nicht präsentabel sein. Dieser zusätzliche Schritt hilft, den endgültigen Bericht ansprechender zu gestalten. Dazu fordern wir das LLM auf, als erfahrener Redakteur zu arbeiten, um den endgültigen Bericht zu verbessern.
def format_final_report(self, raw_report):
"""Add final formatting to the report to make it more professional."""
sys = """You are an expert editor that improves research reports.
Keep all the factual content, citations, and structure intact.
Just improve the formatting, organization, and readability."""
hum = f"""
Here is a research report that needs final formatting improvements:
{raw_report}
Please improve the formatting and presentation while preserving all:
1. Facts and figures
2. Citations
3. Content organization
4. Statistical data
Make it look professional with proper headings, spacing, and layout.
"""
try:
improved = self.llm.invoke([SystemMessage(content=sys), HumanMessage(content=hum)]).content
return improved
except Exception as e:
# If formatting fails, return original report
return raw_report
Zusammenführung aller Komponenten
Lassen Sie uns den gesamten Workflow in einer Pipeline zusammenfassen, die den gesamten Forschungsablauf koordiniert. Dies dient als Einstiegspunkt, der es dem Agenten ermöglicht, den vollständigen Forschungsprozess durchzuführen und dann den endgültigen Bericht zu formatieren.
def run(self, topic):
"""Run the research process on the given topic."""
try:
# Reset stored search results
self.raw_search_results = []
# Run the agent
executor = self.get_agent_executor()
raw_report = executor.invoke({"input": topic})["output"]
# Format the final report
final_report = self.format_final_report(raw_report)
return final_report
except Exception as e:
return f"Research failed: {str(e)}"
Ausführung des Forschungsagenten
Nachdem wir den Deep-Search-Agenten-Workflow gebaut haben, wollen wir ihn testen und sehen, wie gut er bei einer realen Forschungsaufgabe abschneidet.
Wir erstellen eine Instanz des Forschungsagenten und bitten ihn, einen detaillierten Bericht zu einem aktuellen Thema zu erstellen.
# Create the researcher object
researcher = AgenticResearcher(novita_api_key, tavily_api_key, num_researchers=3)
# Run a test research
topic = "What are the most promising climate tech startups in 2025?"
report = researcher.run(topic)
# Display the research report
print("\
" + "="*60)
print(f"📝 DETAILED RESEARCH REPORT: {topic}")
print("="*60)
print(report)
print("="*60 + "\
")
Ergebnis:
Der Deep-Agentic-Workflow zerlegte das Thema und erstellte einen Forschungsplan, führte eine Internetsuche durch, um relevante Informationen zu sammeln, synthetisierte die gesammelten Daten und gab schließlich einen strukturierten Bericht basierend auf der Suchanfrage zurück.
Fazit
Herzlichen Glückwunsch, Sie haben Ihren eigenen Deep-Search-Agenten-Workflow erstellt! Sie können jetzt jedes Thema recherchieren und einen detaillierten Bericht zu Ihrer Anfrage erhalten.
Lassen Sie uns kurz zusammenfassen, was Sie erreicht haben:
In diesem Artikel haben Sie gelernt, wie Sie einen Deep-Search-Agenten erstellen, der komplexe Themen zerlegen, einen Forschungsplan generieren, Internetsuchen durchführen und alle Ergebnisse in einen strukturierten Bericht synthetisieren kann.
Dieser gesamte Workflow wurde unterstützt durch:
- Novita AI als LLM-Anbieter
- LangChain als agentisches Framework
- Tavily als Echtzeit-Suchmaschine
Probieren Sie den Agenten gerne zu verschiedenen Themen aus, um seine Fähigkeiten zu testen!
Dies ist nur eine der vielen spannenden KI-Anwendungen, die mit den heutigen leistungsstarken Modellen möglich sind. Besuchen Sie das Novita LLM Playground, um andere Top-KI-Modelle auszuprobieren; vielleicht beginnt dort Ihre nächste großartige KI-Idee.
Novita AI ist eine KI-Cloud-Plattform, die Entwicklern eine einfache Möglichkeit bietet, KI-Modelle über unsere einfache API bereitzustellen, und gleichzeitig eine erschwingliche und zuverlässige GPU-Cloud zum Erstellen und Skalieren bereitstellt.
