MCP
Intégration du Model Context Protocol pour connecter les agents à des outils et services externes
Vue d'ensemble#
MCP (Model Context Protocol) permet aux agents Astreus de se connecter facilement à des outils et services externes. Définissez des serveurs MCP sous forme d'objets simples avec chargement automatique des variables d'environnement et utilisez-les à différents niveaux - agent, tâche, ou conversation.
Définitions de types#
MCPServerDefinition#
interface MCPServerDefinition {
name: string; // Server name for identification (required)
command?: string; // Command to execute (for stdio servers)
args?: string[]; // Command arguments
env?: Record<string, string>; // Environment variable overrides
url?: string; // URL for SSE servers
cwd?: string; // Working directory
}MCPTool#
interface MCPTool {
name: string;
description: string;
inputSchema: MCPJsonSchema;
}MCPToolResult#
interface MCPToolResult {
content: Array<{
type: string;
text?: string;
}>;
isError?: boolean;
}MCPValue#
type MCPPrimitive = string | number | boolean | null;
type MCPValue = MCPPrimitive | MCPPrimitive[] | { [key: string]: MCPValue };Créer des serveurs MCP#
Définissez des serveurs MCP sous forme d'objets de tableau avec chargement automatique de l'environnement :
import { Agent } from '@astreus-ai/astreus';
// Define MCP servers array
const mcpServers = [
{
name: 'github',
command: "npx",
args: ["-y", "@modelcontextprotocol/server-github"]
// GITHUB_PERSONAL_ACCESS_TOKEN loaded from .env automatically
},
{
name: 'filesystem',
command: "npx",
args: ["-y", "@modelcontextprotocol/server-filesystem", "/Users/username/Documents"]
}
];
const agent = await Agent.create({
name: 'DevAgent',
model: 'gpt-6-astra'
});
// Add MCP servers to agent
await agent.addMCPServers(mcpServers);
// Use automatically in conversations
const response = await agent.ask("List my repositories and save to repos.txt");Exemple#
Voici un exemple complet montrant l'intégration MCP :
import { Agent } from '@astreus-ai/astreus';
// Create agent
const agent = await Agent.create({
name: 'DevAssistant',
model: 'gpt-6-astra',
systemPrompt: 'You are a helpful development assistant with access to various tools.'
});
// Add MCP servers
await agent.addMCPServers([
{
name: 'github',
command: "npx",
args: ["-y", "@modelcontextprotocol/server-github"]
},
{
name: 'filesystem',
command: "npx",
args: ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/project"]
},
{
name: 'search',
command: "npx",
args: ["-y", "@modelcontextprotocol/server-brave-search"]
}
]);
// Agent now has access to GitHub, filesystem, and search tools
const response = await agent.ask(`
Check my latest repositories,
create a summary file in my project directory,
and search for TypeScript best practices
`);
console.log(response);Variables d'environnement#
Les serveurs MCP chargent automatiquement les variables d'environnement depuis votre fichier .env :
# .env
GITHUB_PERSONAL_ACCESS_TOKEN=ghp_xxxxxxxxxxxx
BRAVE_API_KEY=your_brave_api_key
GOOGLE_APPLICATION_CREDENTIALS=/path/to/credentials.jsonAucun besoin de spécifier les variables d'environnement dans le code - elles sont chargées automatiquement et de manière sécurisée.
Types de serveurs#
Serveurs locaux (stdio)#
Pour les serveurs qui s'exécutent en tant que processus locaux :
const localServers = [
{
name: 'sqlite',
command: "npx",
args: ["-y", "@modelcontextprotocol/server-sqlite", "--db-path", "/path/to/db.sqlite"],
cwd: "/working/directory"
}
];Serveurs distants (SSE)#
Pour les serveurs qui se connectent via HTTP/SSE :
const remoteServers = [
{
name: 'api-server',
url: "https://api.example.com/mcp/events"
}
];Utilisation multi-niveaux#
Niveau agent#
Disponible pour toutes les tâches et conversations :
// Agent-level: Available everywhere
await agent.addMCPServers([
{
name: 'filesystem',
command: "npx",
args: ["-y", "@modelcontextprotocol/server-filesystem", "/Users/username/Documents"]
}
]);Niveau tâche#
Disponible pour des tâches spécifiques :
// Task-level: Available for this task only
const task = await agent.createTask({
prompt: "Analyze my GitHub repositories",
mcpServers: [
{
name: 'github',
command: "npx",
args: ["-y", "@modelcontextprotocol/server-github"]
}
]
});Niveau conversation#
Disponible pour des conversations individuelles :
// Conversation-level: Available for this conversation only
const response = await agent.ask("Search for TypeScript news", {
mcpServers: [
{
name: 'search',
command: "npx",
args: ["-y", "@modelcontextprotocol/server-brave-search"]
}
]
});Accès manuel aux outils#
Accédez aux outils MCP de manière programmatique :
// List available MCP tools
const tools: MCPTool[] = agent.getMCPTools();
console.log('Available MCP tools:', tools.map(t => t.name));
// Call specific MCP tool
// Tool name format: "server:tool_name" or just "tool_name" (auto-resolves server)
const result: MCPToolResult = await agent.callMCPTool('github:list_repos', {
owner: 'username'
});
// Remove an MCP server by name (synchronous)
agent.removeMCPServer('github');Types de réponse#
Réponse callMCPTool#
const result: MCPToolResult = await agent.callMCPTool('github:list_repos', { owner: 'username' });
// Response structure (MCPToolResult):
{
content: [
{ type: 'text', text: 'Repository list...' }
],
isError?: boolean // Optional error flag
}Réponse getMCPTools#
const tools: MCPTool[] = agent.getMCPTools();
// Response structure (MCPTool[]):
[
{
name: 'list_repos', // Tool name without server prefix
description: 'List repositories for a user',
inputSchema: { // MCPJsonSchema
type: 'object',
properties: {
owner: { type: 'string', description: 'Repository owner' }
},
required: ['owner']
}
}
]Référence API#
Méthodes MCP de l'agent#
// Add a single MCP server (async)
async addMCPServer(serverDef: MCPServerDefinition): Promise<void>
// Add multiple MCP servers (async)
async addMCPServers(servers: MCPServerDefinition[]): Promise<void>
// Remove an MCP server by name (sync)
removeMCPServer(name: string): void
// Call an MCP tool (async)
async callMCPTool(
toolName: string, // "server:tool" or just "tool"
args: Record<string, MCPValue> // Tool arguments
): Promise<MCPToolResult>
// Get all available MCP tools (sync)
getMCPTools(): MCPTool[]L'intégration MCP offre un accès puissant à des outils externes tout en maintenant la sécurité et la simplicité.