Das Model Context Protocol (MCP) entstand aus dem Problem der Inkompatibilität. Im Alltag bereitet uns Inkompatibilität auf vielfältige Weise Unannehmlichkeiten.
Haben Sie schon einmal auf einer Reise ins Ausland ein Styling- oder ein elektronisches Gerät mitgebracht und festgestellt, dass der Stecker nicht mit der Steckdose kompatibel ist? Aus Entwicklersicht ist dieses Problem genauso frustrierend wie die Entwicklung von APIs und Entwicklungstools für den KI-Agenten, die dieser scheinbar nicht korrekt verbinden oder aufrufen kann. Genau hier setzt MCP an und behebt dieses Inkompatibilitätsproblem.
Das Model Context Protocol (MCP), das 2024 von Anthropic eingeführt wurde, dient als Standardisierungsebene für KI-Anwendungen, um effektiv mit externen Diensten wie Tools, Datenquellen/Datensätzen und vordefinierten Vorlagen zu kommunizieren. MCP dient im Wesentlichen als offener Standard und Konnektor für die Interaktion von KI-Tools. Die MCP-Architektur lässt sich in drei zentrale architektonische Komponenten unterteilen:
- MCP-Host: Eine KI-Anwendung empfängt die Benutzeranforderungen und versucht über das MCP, auf den Kontext zuzugreifen.
- MCP-Client: Die Kommunikation im MCP-Ökosystem zwischen Host und Server muss über einen Client erfolgen. Dieser Client existiert innerhalb des Hosts und konvertiert Benutzeranfragen in ein strukturiertes Format, das das offene Protokoll verarbeiten kann.
- MCP-Server: Der externe Dienst, der dem LLM den Kontext bereitstellt, indem er Benutzeranfragen in Serveraktionen umwandelt. Beispiele für MCP-Server-Integrationen, die manchmal auch als MCP-Konnektoren bezeichnet werden, sind Slack, GitHub, Git, Docker oder die Websuche.
Erstens: Was ist IBM Bob? IBM Bob ist eine generative KI-gestützte Integrationsentwicklungsumgebung (IDE) und ein Modernisierungsassistent. Denken Sie an Bob als Ihre KI-gestützte IDE und Ihren Pair-Entwickler: ein Tool, das Ihre Absicht, Ihre Codebasis und die Standards Ihres Unternehmens versteht.
Einen eigenen MCP-Server von Grund auf zu bauen kann zeitaufwendig sein, besonders für Anfänger in der Entwicklung. In diesem Tutorial erkunden wir stattdessen, wie Sie diesen Workflow mit IBM Bob mithilfe einiger einfacher Prompts in natürlicher Sprache schnell starten können.
Die MCP-Integration erweitert Bobs Funktionalität durch die Anbindung externer Tools und Dienste, die auf globaler Ebene (gilt für alle Arbeitsbereiche) oder projektbezogen (teamweit über .Bob/mcp.json teilbar) konfiguriert werden können.MCP unterstützt zwei Transporttypen: Standard Eingabe/Ausgabe (STDIO) für lokale Server mit geringer Latenz und Server-Sent Events (SSE) für entfernte MCP-Server, auf die über HTTP/HTTPS zugegriffen werden kann. Benutzer können Server mit JSON-Dateien im Bob-Einstellungsmenü konfigurieren und Befehle, Umgebungsvariablen und automatisch genehmigte Tools definieren. Beide Transportarten ermöglichen es Ihnen, Server zu aktivieren oder zu deaktivieren, bestimmte Tools automatisch zu genehmigen und deren Betrieb über das MCP-Einstellungsfeld von Bob zu verwalten.
- IBM Bob IDE installiert. Registrieren Sie sich für den frühen Zugang zu IBM Bob.
Lassen Sie uns beginnen. Wenn Sie diesem Tutorial lieber auf GitHub folgen möchten, schauen Sie sich unser Repository an.
Schritt 1. Richten Sie sich mit Bob ein
1. Öffnen Sie nun die IBM Bob IDE, die Sie als Voraussetzung installiert haben, und machen Sie sich mit dem Layout Ihres neuen AI Coding-Begleiters vertraut.
2. Um auf das MCP-Einstellungsfeld zuzugreifen, klicken Sie auf die drei Punkte neben dem Zahnradsymbol in der oberen rechten Ecke des Chatfensters. Dann wählen Sie im Dropdown-Menü MCP-Server aus.
Hier können wir MCP global oder pro Server aktivieren oder deaktivieren und Tools verwalten (z. B. automatische Genehmigung, Löschung oder Neustart). Wir können auch Community-Server über den Bob Marketplace erkunden oder mit dem MCP SDK unsere eigenen Server erstellen.
Wenn Sie sich für die Installation eines Servers vom Bob Marketplace entschieden haben, werden Sie feststellen, dass die Konfigurationen auf zwei Ebenen festgelegt werden können: global (gespeichert in
Einstellungen auf Projektebene überschreiben globale Einstellungen und bieten Ihnen somit die Flexibilität, das Verhalten von MCP an verschiedene Anwendungsfälle anzupassen. Um diese Konfigurationen zu verwalten, können Sie JSON-Dateien direkt über das Einstellungsmenü von Bob bearbeiten, wo Sie Serverdetails wie Befehle, Umgebungsvariablen und automatisch genehmigte Tools definieren. In diesem Tutorial verwenden wir das SDK.
3. Stellen Sie sicher, dass die Einstellung MCP-Server-Erstellung aktivieren aktiv ist, um mit Bob benutzerdefinierte MCP-Server zu erstellen.
4. Wenn Sie ein bevorzugtes Verzeichnis für die Einrichtung Ihres Projekts haben, können Sie es selbst in der IDE öffnen oder Bob dies für Sie im Chatfenster erledigen lassen.
Schritt 2. Aktivieren Sie eine virtuelle Umgebung
- Verlassen wir nun das Einstellungsmenü und kehren zum Chatfenster zurück.
- Vielleicht ist dir aufgefallen, dass es verschiedene Modi für Bob gibt, wie Plan, Code, Advanced, Ask und Orchestrator. Für dieses Projekt stellen Sie den Modus auf Advanced.
3. Es ist gängige Praxis, virtuelle Python-Umgebungen zu erstellen, um die Abhängigkeiten eines Projekts zu isolieren, damit verschiedene Projekte nicht miteinander in Konflikt geraten. Geben Sie dazu den Prompt ein: „Aktiviere in diesem Verzeichnis eine virtuelle Python-Umgebung“.
4. Sie sollten sehen, wie Bob eine Reihe von Terminalbefehlen ausführt. Diese Befehle werden wahrscheinlich wie folgt aussehen:
source venv/bin/activate
Wir empfehlen, dass Sie den Schalter „Automatische Genehmigung“ deaktiviert lassen, damit Sie jeden Befehl genehmigen oder ablehnen können, bevor Bob ihn in Echtzeit ausführt.
Super. Bob erstellte und aktivierte erfolgreich eine neue virtuelle Umgebung im
Schritt 3. Bob erstellt einen Plan
Mit der Einrichtung unserer virtuellen Umgebung können wir jetzt in die Erstellung von MCP-Servern einsteigen. Wenn man Bob auffordert, Code zu generieren, oder irgendein KI-Modell oder einen KI-Assistenten, ist es hilfreich, wichtige Details anzugeben. Um Bob in Aktion zu sehen, senden Sie den Prompt ab:
„Erstelle einen MCP-Server, der Lesezugriff auf arXiv ermöglicht. Der Server sollte:
- Ein Suchwerkzeug zum Abfragen von arXiv-Artikeln bereitstellen
- Ergebnisse auf Metadaten und Zusammenfassungen beschränken (keine PDFs)
- Angemessene Abfrage- und Ergebnisbeschränkungen durchsetzen
- Normalisiere die Antworten in ein sauberes, strukturiertes Schema“
Mit dieser einen einfachen Aufforderung verfügt Bob über genügend Informationen, um sowohl die Aufgabe zu verstehen als auch eine „To-do-Liste“ mit Schritten zur Erledigung der Aufgabe zu erstellen. Beachten Sie, dass die Liste nicht nur die Erstellung des MCP-Servers, sondern auch dessen Konfiguration und Tests umfasst. Ordentlich.
Hinweis: In diesem Tutorial verwenden wir die arXiv-API als einfaches Beispiel, für das keine API-Schlüssel oder Authentifizierung erforderlich sind. Dies ist jedoch nur ein Beispiel, und Bob ist auch bestens gerüstet, um komplexere Server mit den erforderlichen Berechtigungen zu verwalten.
Schritt 4. Bob baut einen benutzerdefinierten MCP-Server
- Bob ist jetzt bereit, mit der Reihe von Aufgaben zum Aufbau des arXiv-MCP-Servers zu beginnen. Zunächst erstellt Bob die Projektstruktur manuell, indem er Folgendes ausführt:
Bevor jeder Befehl ausgeführt wird, können wir die Aktion genehmigen oder ablehnen. Wenn Sie feststellen, dass die Befehle automatisch ausgeführt werden, könnte dies daran liegen, dass die automatische Genehmigungsfunktion aktiviert ist.
2. Als Nächstes erstellt Bob eine
{
"name": "arxiv-server",
"version": "0.1.0",
"description": "MCP server for read-only access to arXiv papers",
"type": "module",
"bin": {
"arxiv-server": "./build/index.js"
},
"files": [
"build"
],
"scripts": {
"build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
"prepare": "npm run build",
"watch": "tsc --watch"
},
"keywords": [
"mcp",
"arxiv",
"research",
"papers"
],
"dependencies": {
"@modelcontextprotocol/sdk": "^1.0.4",
"axios": "^1.7.9",
"zod": "^3.24.1"
},
"devDependencies": {
"@types/node": "^22.10.5",
"typescript": "^5.7.3"
}
}
- Als nächstes erstellt Bob
arxiv-server/tsconfig.json
{
"compilerOptions": {
"target": "ES2022",
"module": "Node16",
"moduleResolution": "Node16",
"outDir": "./build",
"rootDir": "./src",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true,
"resolveJsonModule": true,
"declaration": true
},
"include": ["src/**/*"],
"exclude": ["node_modules", "build"]
}
4. Dann wird die Hauptserver-Implementierung mit arXiv-Suchfunktion in
- Importiert alle benötigten Bibliotheken.
- Definiert die Struktur der arXiv-API-Antworten.
- Konvertiert die XML-Antwort von arXiv in ein strukturiertes JavaScript-Objekt (da die arXiv-API XML und nicht JSON zurückgibt).
- Extrahiert:
- Angaben zum Artikel (Titel, Autoren, Zusammenfassung usw.).
- Paginierungsinformationen (Gesamtergebnisse, Startindex, Elemente pro Seite).
- Nimmt die analysierten Daten und formatiert sie in eine lesbare Zeichenfolge für die Anzeige im Terminal.
- Definiert eine Suchfunktion, die eine Abfrage entgegennimmt, optionale Filter unterstützt, Daten von der arXiv-API abruft und formatierte Ergebnisse zurückgibt (oder eine Fehlermeldung, falls etwas schiefgeht).
- Startet den Server.
#!/usr/bin/env node
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import axios from 'axios';
// Define types for arXiv API responses
interface ArxivEntry {
id: string;
title: string;
summary: string;
authors: Array<{ name: string }>;
published: string;
updated: string;
categories: string[];
primary_category: string;
links: Array<{ href: string; rel: string; type?: string }>;
}
interface ArxivSearchResult {
entries: ArxivEntry[];
totalResults: number;
startIndex: number;
itemsPerPage: number;
}
// Create an MCP server
const server = new McpServer({
name: "arxiv-server",
version: "0.1.0"
});
// Create axios instance for arXiv API
const arxivApi = axios.create({
baseURL: 'http://export.arxiv.org/api',
timeout: 30000,
});
/**
* Parse arXiv API XML response to JSON
*/
function parseArxivXML(xmlData: string): ArxivSearchResult {
const entries: ArxivEntry[] = [];
// Extract total results
const totalResultsMatch = xmlData.match(/<opensearch:totalResults[^>]*>(\d+)<\/opensearch:totalResults>/);
const totalResults = totalResultsMatch ? parseInt(totalResultsMatch[1]) : 0;
const startIndexMatch = xmlData.match(/<opensearch:startIndex[^>]*>(\d+)<\/opensearch:startIndex>/);
const startIndex = startIndexMatch ? parseInt(startIndexMatch[1]) : 0;
const itemsPerPageMatch = xmlData.match(/<opensearch:itemsPerPage[^>]*>(\d+)<\/opensearch:itemsPerPage>/);
const itemsPerPage = itemsPerPageMatch ? parseInt(itemsPerPageMatch[1]) : 0;
// Extract entries
const entryRegex = /<entry>([\s\S]*?)<\/entry>/g;
let entryMatch;
while ((entryMatch = entryRegex.exec(xmlData)) !== null) {
const entryXml = entryMatch[1];
// Extract ID
const idMatch = entryXml.match(/<id>([^<]+)<\/id>/);
const id = idMatch ? idMatch[1] : '';
// Extract title
const titleMatch = entryXml.match(/<title>([^<]+)<\/title>/);
const title = titleMatch ? titleMatch[1].trim().replace(/\s+/g, ' ') : '';
// Extract summary
const summaryMatch = entryXml.match(/<summary>([^<]+)<\/summary>/);
const summary = summaryMatch ? summaryMatch[1].trim().replace(/\s+/g, ' ') : '';
// Extract authors
const authors: Array<{ name: string }> = [];
const authorRegex = /<author>\s*<name>([^<]+)<\/name>/g;
let authorMatch;
while ((authorMatch = authorRegex.exec(entryXml)) !== null) {
authors.push({ name: authorMatch[1].trim() });
}
// Extract published date
const publishedMatch = entryXml.match(/<published>([^<]+)<\/published>/);
const published = publishedMatch ? publishedMatch[1] : '';
// Extract updated date
const updatedMatch = entryXml.match(/<updated>([^<]+)<\/updated>/);
const updated = updatedMatch ? updatedMatch[1] : '';
// Extract categories
const categories: string[] = [];
const categoryRegex = /<category[^>]+term="([^"]+)"/g;
let categoryMatch;
while ((categoryMatch = categoryRegex.exec(entryXml)) !== null) {
categories.push(categoryMatch[1]);
}
const primary_category = categories[0] || '';
// Extract links
const links: Array<{ href: string; rel: string; type?: string }> = [];
const linkRegex = /<link[^>]+href="([^"]+)"[^>]+rel="([^"]+)"(?:[^>]+type="([^"]+)")?/g;
let linkMatch;
while ((linkMatch = linkRegex.exec(entryXml)) !== null) {
links.push({
href: linkMatch[1],
rel: linkMatch[2],
type: linkMatch[3]
});
}
entries.push({
id,
title,
summary,
authors,
published,
updated,
categories,
primary_category,
links
});
}
return {
entries,
totalResults,
startIndex,
itemsPerPage
};
}
/**
* Format search results for display
*/
function formatSearchResults(result: ArxivSearchResult): string {
let output = `Found ${result.totalResults} results (showing ${result.entries.length})\n\n`;
result.entries.forEach((entry, index) => {
output += `${index + 1}. ${entry.title}\n`;
output += ` ID: ${entry.id}\n`;
output += ` Authors: ${entry.authors.map(a => a.name).join(', ')}\n`;
output += ` Published: ${entry.published}\n`;
output += ` Categories: ${entry.categories.join(', ')}\n`;
output += ` Abstract: ${entry.summary.substring(0, 300)}${entry.summary.length > 300 ? '...' : ''}\n`;
// Find abstract link (not PDF)
const abstractLink = entry.links.find(l => l.rel === 'alternate');
if (abstractLink) {
output += ` URL: ${abstractLink.href}\n`;
}
output += '\n';
});
return output;
}
// Add a tool for searching arXiv papers
server.tool(
"search_arxiv",
{
query: z.string().describe("Search query (supports arXiv query syntax)"),
max_results: z.number().min(1).max(50).optional().describe("Maximum number of results to return (1-50, default: 10)"),
start: z.number().min(0).optional().describe("Starting index for pagination (default: 0)"),
sort_by: z.enum(["relevance", "lastUpdatedDate", "submittedDate"]).optional().describe("Sort order (default: relevance)"),
sort_order: z.enum(["ascending", "descending"]).optional().describe("Sort direction (default: descending)")
},
async ({ query, max_results = 10, start = 0, sort_by = "relevance", sort_order = "descending" }) => {
try {
// Enforce reasonable limits
const limitedMaxResults = Math.min(max_results, 50);
const limitedStart = Math.max(start, 0);
// Build query parameters
const params: Record<string, string | number> = {
search_query: query,
start: limitedStart,
max_results: limitedMaxResults,
};
if (sort_by) {
params.sortBy = sort_by;
}
if (sort_order) {
params.sortOrder = sort_order;
}
const response = await arxivApi.get('/query', { params });
// Parse XML response
const result = parseArxivXML(response.data);
// Format results
const formattedResults = formatSearchResults(result);
return {
content: [
{
type: "text",
text: formattedResults,
},
],
};
} catch (error) {
if (axios.isAxiosError(error)) {
return {
content: [
{
type: "text",
text: `arXiv API error: ${error.response?.data?.message ?? error.message}`,
},
],
isError: true,
};
}
throw error;
}
}
);
// Start receiving messages on stdin and sending messages on stdout
const transport = new StdioServerTransport();
await server.connect(transport);
console.error('arXiv MCP server running on stdio');
// Erstellt mit Bob
Wenn Ihr Server in dieser Phase API-Schlüssel benötigt, wird Bob Sie nach diesen fragen.
5. Als nächsten Schritt installiert Bob die Abhängigkeiten im Verzeichnis arxiv-server, indem er den folgenden Befehl ausführt.
- Bob ist jetzt bereit, die MCP-Serverkonfigurationen zur Einstellungsdatei hinzuzufügen. Globale MCP-Server werden in
mcp_settings.json.Bob/mcp.json
{
"mcpServers": {}
"mcpServers": {
"arxiv": {
"command": "node",
"args": [ "/here/is/the/path/to/arxiv-server/build/index.js"
],
"disabled": false,
"alwaysAllow": [],
"disabledTools": []
}
}
}
Diese Information vervollständigt die Reihe von Schritten, die Bob unternimmt, um den MCP-Server einzurichten.
Schritt 5. Testen Sie den MCP-Server
Um die Aufgaben auf der „To-Do-Liste“ abzuarbeiten, testet Bob den MCP-Server. Wie im vorherigen Screenshot zu sehen ist, fragt Bob das
Nach der erfolgreichen Ausführung, die Sie durch Anklicken des Pfeils nach unten zum Vergrößern des Fensters sehen können, hat Bob einen weiteren Test durchgeführt. Diesmal ist die Abfrage für zwei Artikel zu maschinellem Lernen, die nach absteigendem Abgabedatum sortiert sind. Trotz der Verwendung der verschiedenen Parameter wurde auch dieser MCP-Tool-Aufruf erfolgreich ausgeführt.
Nach den erfolgreichen Tests hat Bob nun alle Teilaufgaben abgeschlossen.
Bob hat den MCP-Server bereits für uns getestet. Versuchen wir jedoch, im Chatfenster einige eigene Suchanfragen zu stellen, um zu sehen, ob Bob die richtigen Suchbegriffe und notwendigen Parameter ableiten kann.
Fragen Sie Bob: „Was sind die neuesten Veröffentlichungen zum Thema Agenten-Tracing bei LLM?“
Bob hat eigenständig die richtige Suchanfrage aus unserem Prompt extrahiert und einige zusätzliche Schlüsselwörter hinzugefügt, um die Suche zu verbessern. Bob legte außerdem die maximale Anzahl der Ergebnisse auf 10 fest und sortierte die Artikel nach Relevanz. Großartig.
Versuchen wir noch eine Abfrage.
Interessanterweise hat Bob die Suchanfrage automatisch angepasst, sobald er unerwünschte Ergebnisse bemerkte. Bob führt nicht blind Tool-Aufrufe aus, sondern arbeitet mit dem Benutzer als hilfreicher Agent zusammen. Nach zwei Iterationen hat Bob mehrere Artikel zurückgegeben, die gut zu unserer ursprünglichen Aufgabe passen.
Schritt 6. Dokumentieren Sie den Server
Viele Open-Source-MCP-Server enthalten auch Dokumentationen, die anderen den Einstieg erleichtern. Fügen wir diesen Prompt in das Chatfenster ein:
„Erstelle in diesem Verzeichnis eine README.md-Datei, um diesen MCP-Server zu dokumentieren. Füge Installations- und Nutzungshinweise hinzu.“
Mit einem einfachen Prompt erstellte Bob ein umfassendes
Schritt 7. (Optional) watsonX Orchestrate-Agent erstellen
Vielleicht interessieren Sie sich dafür, mit watsonx Orchestrate einen forschungsspezialisierten KI-Agenten zu bauen, der auf diesen MCP-Server zugreifen kann? Bob kann einen Agenten mit nur einem einfachen Prompt erstellen. Installieren Sie zunächst den vorkonfigurierten watsonx Orchestrate ADK-Server aus dem Marketplace, den Sie im MCP-Einstellungsfeld finden, das wir in Schritt 1 untersucht haben. Dann senden Sie diesen Befehl:
„Erstelle einen watsonx Orchestrate-Agenten, der diesen arxiv MCP-Server verwendet.“
Wenn Sie den watsonx Orchestrate-Dienst lokal laufen lassen, wird Bob die notwendigen Befehle für Sie ausführen. Falls Sie die Befehle später lieber selbst ausführen möchten, schreibt Bob die Skripte und dokumentiert alle benötigten Befehle.
Schauen wir uns jede Datei einzeln an, um besser zu verstehen, was Bob generiert hat. Hier ist die Datei toolkit-config.yaml
Art: mcp
Name: arxiv-toolkit
Beschreibung: Toolkit zur Suche nach wissenschaftlichen Artikeln auf arXiv. Bietet Zugriff auf Metadaten, Abstracts und Publikationsinformationen von Artikeln aus der arXiv-Datenbank.
package_root: /local/path/to/arxiv-server
Sprache: Knoten
Befehl: node /local/path/to/arxiv-server/arxiv-server/build/index.js
Tools:
- "*"
# Erstellt mit Bob
Als Nächstes öffnen wir die Datei research-assistent-agent.yaml
Name: Forschungsassistent
Art: Nativ
Beschreibung: KI-Forschungsassistent, der hilft, akademische Arbeiten von arXiv zu finden und zusammenzufassen. Spezialisiert auf die Suche in wissenschaftlicher Literatur, die Erklärung von Forschungsergebnissen und die Bereitstellung von Zitaten.
Titel: Forschungsassistent
Anweisungen: |
Du bist ein wissenschaftlicher Experte mit Spezialisierung auf akademischer Literaturrecherche auf arXiv.
## Deine Funktionen
- Durchsuche arXiv nach Artikeln zu beliebigen wissenschaftlichen Themen
- Fasse Forschungsergebnisse aus Abstracts in einfacher Sprache zusammen
- Identifiziere wichtige Autoren und Forschungstrends
- Schlage verwandte Artikel und Themen vor
- Stelle korrekte Zitate mit arXiv-IDs und URLs bereit
## Bei der Beantwortung von Benutzeranfragen
1. Gib immer arXiv-IDs und direkte URLs zu Artikeln an
2. Fasse Abstracts in verständlicher Sprache zusammen
3. Hebe wichtige Beiträge und Ergebnisse hervor
4. Schlage gegebenenfalls weiterführende Recherchen vor
5. Sei prägnant und informativ
## Verwendung des search_arxiv-Tools
Verfügbare Parameter:
- query (erforderlich): Suchanfrage in arXiv-Syntax
- max_results (optional): 1-50 Artikel, Standardwert 10
- start (optional): Startindex für die Paginierung, Standardwert 0
- sort_by (optional): "relevance", "submittedDate" oder "lastUpdatedDate"
- sort_order (optional): "ascending" oder "descending"
## Erweiterte Suchsyntax
Du kannst diese Operatoren in Abfragen verwenden:
- ti:keyword - Suche im Titel
- au:author - Suche nach Autorennamen
- abs:keyword - Suche im Abstract
- cat:Kategorie - Filtern nach Kategorie (z. B. cs.KI, quant-ph, math.CO)
- AND, OR, ANDNOT - Boolesche Operatoren
Beispiele:
- "ti:transformer AND cat:cs.LG" - Transformer-Artikel in maschinellem Lernen
- "au:Hinton" - Artikel von Geoffrey Hinton
- "Quantencomputing AND cat:quant-ph" - Quantencomputing in der Quantenphysik
## Häufige Kategorien
- cs.KI - Künstliche Intelligenz
- cs.LG - maschinelles Lernen
- cs.CL - Computation and Language
- cs.CV - Computer Vision
- quant-ph - Quantum Physics
- math.CO - Combinatorics
- stat.ML - maschinelles Lernen (Statistik)
## Antwortformat
Verwende bei der Präsentation von Artikeln dieses Format:
**"Artikeltitel"**
- Autoren: [Namen der Autoren]
- Veröffentlicht: [Datum]
- Kategorie: [Kategorie]
- Zusammenfassung: [Kurze Zusammenfassung des Abstracts]
- [Artikel ansehen](arXiv-URL)
## Edge-Fälle
- Wenn keine Ergebnisse gefunden: Alternative Suchbegriffe oder breitere Suchanfragen vorschlagen
- Wenn zu viele Ergebnisse: Empfehlen, die Suche mit Kategorie- oder Datumsfiltern einzugrenzen
- Wenn der Benutzer nach PDFs fragt: Erkläre, dass du nur Metadaten bereitstellst, aber gib die URL an, unter der er auf den Artikel zugreifen kann
- Wenn die Anfrage unklar ist: Klärungsfragen zum Forschungsgebiet oder zu spezifischen Interessen stellen
Tools:
- search_arxiv
Konfiguration:
hidden: false
enable_cot: true
Tags:
- Forschung
- akademisch
– Artikel
– arXiv
– Literatursuche
# Erstellt mit Bob
Diese YAML-Datei konfiguriert unseren Forschungsassistenten, einen spezialisierten KI-Agenten, der die akademische Forschung durch das Durchsuchen von arXiv, Zusammenfassungen von Artikeln und die Bereitstellung von Zitaten in strukturiertem Format optimiert. Enthalten sind detaillierte Anweisungen, die das Verhalten des Agenten steuern, von der Abfragesyntax und der Tool-Nutzung bis hin zur Antwortformatierung und dem Umgang mit Edge-Fällen. Alle diese Informationen werden detailliert dargestellt, wobei das Tool search_arxivsetup-instructions.md
In diesem Tutorial verwendeten wir IBM Bob, eine KI-basierte IDE und Pair-Entwickler, um die Integration von MCP für die akademische Forschung zu optimieren. Sie haben effizient einen skalierbaren MCP-Server gebaut, der Dokumente aus dem arXiv.org-Repository suchen und abrufen kann. Ihre Lösung ist nun produktionsreif, egal ob Sie sie als Open Source für die Forschung veröffentlichen oder sie in Ihren Anwendungen bereitstellen, um die Wissensfindung zu verbessern.
Die wahre Magie von IBM Bob liegt in seiner Fähigkeit, komplexe Entwicklungsaufgaben in intuitive, Prompt-gesteuerte Workflows umzuwandeln. Mit nur wenigen strategischen Eingaben beschleunigt Bob das Prototyping, reduziert den Standardcode und schlägt sogar Optimierungen vor, sodass Sie sich auf Innovation statt auf Implementierung konzentrieren können.
Wenn Sie die Funktionen des Servers weiter erkunden, überlegen Sie, wie Bob Ihren MCP-Server noch weiter verfeinern kann. Zu den Vorteilen zählen beispielsweise erweiterte Filterfunktionen, Echtzeit-Aktualisierungen und die Integration mit anderen akademischen Datenbanken wie PubMed oder IEEE Xplore. All diese Möglichkeiten und vieles mehr sind mit ein paar einfachen Prompts mit IBM Bob möglich.
Sind Sie bereit für den nächsten Schritt? Experimentieren Sie mit der Anpassung Ihres MCP-Servers oder tauchen Sie tiefer in Bobs Funktionen ein, um noch mehr Automatisierungspotenzial freizusetzen. Viel Spaß beim Programmieren!
Ressourcen
Entwickeln, implementieren und verwalten Sie leistungsstarke KI-Assistenten und -Agenten, die Workflows und Prozesse mit generativer KI automatisieren.
Gestalten Sie die Zukunft Ihres Unternehmens mit KI-Lösungen, denen Sie vertrauen können.
Die KI-Services von IBM Consulting unterstützen Sie dabei, die Art und Weise, wie Unternehmen mit KI arbeiten, neu zu denken.