Fonctionnalités

Explication détaillée de chaque fonctionnalité que vous pouvez inclure lors de la création d'un nouvel agent.

Mémoire

Activez la mémoire persistante pour votre agent. L'agent se souvient des conversations d'une session à l'autre grâce à la recherche vectorielle pour une récupération efficace.

const agent = await Agent.create({
  name: 'my-agent',
  model: 'gpt-4o',
  memory: true,
});

await agent.ask("My name is John");
// Later, even in a new session:
await agent.ask("What's my name?"); // "Your name is John"

Cas d'usage :

Assistants personnels qui se souviennent des préférences de l'utilisateur
Bots de support client avec historique de conversation
Agents de longue durée nécessitant une persistance du contexte

Connaissance (RAG)

Ajoutez des capacités de récupération de documents. Ingérez des PDF, des fichiers texte et d'autres documents dans une base de connaissances consultable.

const agent = await Agent.create({
  name: 'my-agent',
  model: 'gpt-4o',
  knowledge: true,
});

// Add documents to knowledge base
await agent.addKnowledgeFromFile('./docs/guide.pdf', { category: 'docs' });
await agent.addKnowledgeFromFile('./docs/api.md', { category: 'api' });

// Agent answers from documents
await agent.ask("What does the guide say about authentication?");

Cas d'usage :

Bots de questions-réponses sur la documentation
Assistants de recherche
Systèmes de gestion des connaissances

Prérequis : PostgreSQL avec l'extension pgvector

Graph Workflows

Créez des workflows complexes à plusieurs étapes grâce à l'orchestration de tâches basée sur des DAG. Définissez les dépendances entre les tâches et exécutez-les en parallèle lorsque c'est possible.

import { Agent, Graph } from '@astreus-ai/astreus';

const agent = await Agent.create({ name: 'my-agent', model: 'gpt-4o' });
const graph = new Graph({ name: 'research-workflow' }, agent);

// Define workflow nodes
const researchNode = graph.addTaskNode({
  prompt: 'Research the topic thoroughly'
});

const analyzeNode = graph.addTaskNode({
  prompt: 'Analyze the research findings',
  dependsOn: [researchNode]
});

const writeNode = graph.addTaskNode({
  prompt: 'Write a comprehensive report',
  dependsOn: [analyzeNode]
});

// Execute the workflow
const result = await graph.run();
console.log(result.results);

Cas d'usage :

Génération de contenu à plusieurs étapes
Pipelines de traitement de données
Workflows de décision complexes

Sub-Agents

Coordonnez plusieurs agents spécialisés pour des tâches complexes. Chaque sous-agent peut avoir sa propre configuration et son expertise.

// Create specialized agents
const researcher = await Agent.create({
  name: 'researcher',
  model: 'gpt-4o',
  systemPrompt: 'You are a research specialist.'
});

const writer = await Agent.create({
  name: 'writer',
  model: 'gpt-4o',
  systemPrompt: 'You are a professional writer.'
});

// Main agent coordinates sub-agents
const agent = await Agent.create({ name: 'coordinator', model: 'gpt-4o' });

const result = await agent.executeWithSubAgents(
  'Research and write an article about quantum computing',
  [researcher, writer]
);

Cas d'usage :

Pipelines de création de contenu
Systèmes experts avec plusieurs domaines
Exécution de tâches en parallèle

Custom Plugins

Étendez votre agent avec des outils personnalisés. Définissez les paramètres, descriptions et gestionnaires pour chaque outil.

const weatherPlugin = {
  name: 'weather-plugin',
  version: '1.0.0',
  description: 'Get weather information',
  tools: [{
    name: 'get_weather',
    description: 'Get current weather for a location',
    parameters: {
      location: {
        type: 'string',
        description: 'City name',
        required: true
      }
    },
    handler: async ({ location }) => {
      const response = await fetch(`https://api.weather.com/${location}`);
      const data = await response.json();
      return { success: true, data };
    }
  }]
};

const agent = await Agent.create({ name: 'my-agent', model: 'gpt-4o' });
await agent.registerPlugin(weatherPlugin);

// Agent can now use the weather tool
await agent.ask("What's the weather in Tokyo?");

Cas d'usage :

Intégrations d'API
Opérations sur les bases de données
Logique métier personnalisée

MCP Integration

Support du Model Context Protocol pour une intégration standardisée des outils. Connectez-vous à des services et outils compatibles MCP.

const agent = await Agent.create({
  name: 'my-agent',
  model: 'gpt-4o',
  mcp: {
    servers: [
      { name: 'filesystem', command: 'mcp-server-filesystem' },
      { name: 'github', command: 'mcp-server-github' }
    ]
  }
});

Cas d'usage :

Opérations sur le système de fichiers
Intégration GitHub
Écosystème d'outils standardisé

Combinaisons de fonctionnalités

Les fonctionnalités fonctionnent ensemble de manière fluide :

const agent = await Agent.create({
  name: 'advanced-agent',
  model: 'gpt-4o',
  memory: true,           // Remember conversations
  knowledge: true,        // Access documents
  mcp: {                  // Use MCP tools
    servers: [
      { name: 'filesystem', command: 'mcp-server-filesystem' }
    ]
  }
});

// Register custom plugins
await agent.registerPlugin(myCustomPlugin);

// Use with graph workflows
const graph = new Graph({ name: 'workflow' }, agent);

Dernière mise à jour : 6 juillet 2026

Dans cette section

Introduction

Créez des projets d'agent Astreus AI avec les meilleures pratiques et des paramètres par défaut sensés. Configurez votre agent de manière interactive avec...

Configuration

Variables d'environnement et options de configuration pour votre projet d'agent Astreus. Découvrez les schémas de configuration, les API et les exemples...

Démarrage rapide

Modèles