What is AIGNE Framework
AIGNE Framework [ ˈei dʒən ] is a functional AI application development framework designed to simplify and accelerate the process of building modern applications. It combines functional programming features, powerful artificial intelligence capabilities, and modular design principles to help developers easily create scalable solutions. AIGNE Framework is also deeply integrated with the Blocklet ecosystem, providing developers with a wealth of tools and resources.
Key Features
- Modular Design: With a clear modular structure, developers can easily organize code, improve development efficiency, and simplify maintenance.
- TypeScript Support: Comprehensive TypeScript type definitions are provided, ensuring type safety and enhancing the developer experience.
- Multiple AI Model Support: Built-in support for OpenAI, Gemini, Claude, Nova and other mainstream AI models, easily extensible to support additional models.
- Flexible Workflow Patterns: Support for sequential, concurrent, routing, handoff and other workflow patterns to meet various complex application requirements.
- Agentic File System (AFS): A virtual file system abstraction that provides AI agents with unified access to various storage backends, including local files, conversation history, and user profiles. See AFS Documentation for details.
- MCP Protocol Integration: Seamless integration with external systems and services through the Model Context Protocol.
- Code Execution Capabilities: Support for executing dynamically generated code in a secure sandbox, enabling more powerful automation capabilities.
- Blocklet Ecosystem Integration: Closely integrated with ArcBlock's Blocklet ecosystem, providing developers with a one-stop solution for development and deployment.
Quick Start
Environment Requirements
- Node.js version 20.0 or higher
Installation
Using npm
npm install @aigne/core
Using yarn
yarn add @aigne/core
Using pnpm
pnpm add @aigne/core
Usage Example
import { AIAgent, AIGNE } from "@aigne/core";
import { OpenAIChatModel } from "@aigne/openai";
const { OPENAI_API_KEY } = process.env;
const model = new OpenAIChatModel({
apiKey: OPENAI_API_KEY,
});
function transferToB() {
return agentB;
}
const agentA = AIAgent.from({
name: "AgentA",
instructions: "You are a helpful agent.",
outputKey: "A",
skills: [transferToB],
inputKey: "message",
});
const agentB = AIAgent.from({
name: "AgentB",
instructions: "Only speak in Haikus.",
outputKey: "B",
inputKey: "message",
});
const aigne = new AIGNE({ model });
const userAgent = aigne.invoke(agentA);
const result1 = await userAgent.invoke({ message: "transfer to agent b" });
console.log(result1);
// Output:
// {
// B: "Transfer now complete, \nAgent B is here to help. \nWhat do you need, friend?",
// }
const result2 = await userAgent.invoke({ message: "It's a beautiful day" });
console.log(result2);
// Output:
// {
// B: "Sunshine warms the earth, \nGentle breeze whispers softly, \nNature sings with joy. ",
// }
Architecture diagram
Simplifying Agentic Workflows
The AIGNE Framework offers multiple workflow patterns, each tailored to address distinct application scenarios efficiently.
Workflow Patterns
- Workflow Router - Implement intelligent routing logic to direct requests to appropriate handlers based on content.
- Workflow Sequential - Build step-by-step processing pipelines with guaranteed execution order.
- Workflow Concurrency - Optimize performance by processing multiple tasks simultaneously with parallel execution.
- Workflow Handoff - Create seamless transitions between specialized agents to solve complex problems.
- Workflow Reflection - Enable self-improvement through output evaluation and refinement capabilities.
- Workflow Orchestration - Coordinate multiple agents working together in sophisticated processing pipelines.
- Workflow Code Execution - Safely execute dynamically generated code within AI-driven workflows.
- Workflow Group Chat - Share messages and interact with multiple agents in a group chat environment.
Sequential
Use Cases: Processing multi-step tasks that require a specific execution order, such as content generation pipelines, multi-stage data processing, etc.
flowchart LR
in(In)
out(Out)
conceptExtractor(Concept Extractor)
writer(Writer)
formatProof(Format Proof)
in --> conceptExtractor --> writer --> formatProof --> out
classDef inputOutput fill:#f9f0ed,stroke:#debbae,stroke-width:2px,color:#b35b39,font-weight:bolder;
classDef processing fill:#F0F4EB,stroke:#C2D7A7,stroke-width:2px,color:#6B8F3C,font-weight:bolder;
class in inputOutput
class out inputOutput
class conceptExtractor processing
class writer processing
class formatProof processing
Example: @aigne/example-workflow-sequential: Pipeline
Concurrency
Use Cases: Scenarios requiring simultaneous processing of multiple independent tasks to improve efficiency, such as parallel data analysis, multi-dimensional content evaluation, etc.
flowchart LR
in(In)
out(Out)
featureExtractor(Feature Extractor)
audienceAnalyzer(Audience Analyzer)
aggregator(Aggregator)
in --> featureExtractor --> aggregator
in --> audienceAnalyzer --> aggregator
aggregator --> out
classDef inputOutput fill:#f9f0ed,stroke:#debbae,stroke-width:2px,color:#b35b39,font-weight:bolder;
classDef processing fill:#F0F4EB,stroke:#C2D7A7,stroke-width:2px,color:#6B8F3C,font-weight:bolder;
class in inputOutput
class out inputOutput
class featureExtractor processing
class audienceAnalyzer processing
class aggregator processing
Example: @aigne/example-workflow-concurrency: Concurrency
Router
Use Cases: Scenarios where requests need to be routed to different specialized processors based on input content type, such as intelligent customer service systems, multi-functional assistants, etc.
flowchart LR
in(In)
out(Out)
triage(Triage)
productSupport(Product Support)
feedback(Feedback)
other(Other)
in ==> triage
triage ==> productSupport ==> out
triage -.-> feedback -.-> out
triage -.-> other -.-> out
classDef inputOutput fill:#f9f0ed,stroke:#debbae,stroke-width:2px,color:#b35b39,font-weight:bolder;
classDef processing fill:#F0F4EB,stroke:#C2D7A7,stroke-width:2px,color:#6B8F3C,font-weight:bolder;
class in inputOutput
class out inputOutput
class triage processing
class productSupport processing
class feedback processing
class other processing
Example: @aigne/example-workflow-router: Router
Handoff
Use Cases: Scenarios requiring control transfer between different specialized agents to solve complex problems, such as expert collaboration systems, etc.
flowchart LR
in(In)
out(Out)
agentA(Agent A)
agentB(Agent B)
in --> agentA --transfer to b--> agentB --> out
classDef inputOutput fill:#f9f0ed,stroke:#debbae,stroke-width:2px,color:#b35b39,font-weight:bolder;
classDef processing fill:#F0F4EB,stroke:#C2D7A7,stroke-width:2px,color:#6B8F3C,font-weight:bolder;
class in inputOutput
class out inputOutput
class agentA processing
class agentB processing
Example: @aigne/example-workflow-handoff: Task handoff
Reflection
Use Cases: Scenarios requiring self-assessment and iterative improvement of output quality, such as code reviews, content quality control, etc.
flowchart LR
in(In)
out(Out)
coder(Coder)
reviewer(Reviewer)
in --Ideas--> coder ==Solution==> reviewer --Approved--> out
reviewer ==Rejected==> coder
classDef inputOutput fill:#f9f0ed,stroke:#debbae,stroke-width:2px,color:#b35b39,font-weight:bolder;
classDef processing fill:#F0F4EB,stroke:#C2D7A7,stroke-width:2px,color:#6B8F3C,font-weight:bolder;
class in inputOutput
class out inputOutpu