Funktionen

Detaillierte Erklärung jeder Funktion, die du beim Scaffolding eines neuen Agenten einbeziehen kannst.

Memory

Aktiviere persistentes Memory für deinen Agenten. Der Agent erinnert sich über Sitzungen hinweg an Unterhaltungen und nutzt dafür Vektorsuche für effizientes Abrufen.

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"

Anwendungsfälle:

Persönliche Assistenten, die sich Nutzerpräferenzen merken
Kundensupport-Bots mit Gesprächsverlauf
Langlebige Agenten, die Kontextpersistenz benötigen

Knowledge (RAG)

Füge Funktionen zum Abrufen von Dokumenten hinzu. Nimm PDFs, Textdateien und andere Dokumente in eine durchsuchbare Wissensdatenbank auf.

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?");

Anwendungsfälle:

Dokumentations-Q&A-Bots
Recherche-Assistenten
Wissensmanagement-Systeme

Voraussetzungen: PostgreSQL mit der pgvector-Erweiterung

Graph Workflows

Erstelle komplexe mehrstufige Workflows mit DAG-basierter Task-Orchestrierung. Definiere Abhängigkeiten zwischen Aufgaben und führe sie, wo möglich, parallel aus.

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);

Anwendungsfälle:

Mehrstufige Inhaltserstellung
Datenverarbeitungspipelines
Komplexe Entscheidungs-Workflows

Sub-Agents

Koordiniere mehrere spezialisierte Agenten für komplexe Aufgaben. Jeder Sub-Agent kann seine eigene Konfiguration und Expertise haben.

// 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]
);

Anwendungsfälle:

Content-Erstellungs-Pipelines
Expertensysteme mit mehreren Fachbereichen
Parallele Aufgabenausführung

Custom Plugins

Erweitere deinen Agenten mit benutzerdefinierten Tools. Definiere Parameter, Beschreibungen und Handler für jedes Tool.

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?");

Anwendungsfälle:

API-Integrationen
Datenbankoperationen
Individuelle Geschäftslogik

MCP-Integration

Unterstützung für das Model Context Protocol für standardisierte Tool-Integration. Verbinde dich mit MCP-kompatiblen Diensten und Tools.

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' }
    ]
  }
});

Anwendungsfälle:

Dateisystemoperationen
GitHub-Integration
Standardisiertes Tool-Ökosystem

Kombination von Funktionen

Funktionen arbeiten nahtlos zusammen:

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);

Zuletzt aktualisiert: 6. Juli 2026

In diesem Abschnitt

Einführung

Erstelle neue Astreus-AI-Agentenprojekte mit Best Practices und sinnvollen Standardeinstellungen. Konfiguriere deinen Agenten interaktiv mit den Funktionen,...

Konfiguration

Umgebungsvariablen und Konfigurationsoptionen für dein Astreus-Agentenprojekt. Lerne die Einrichtungsmuster, APIs und praktischen Beispiele kennen, die du...