nonebot/nonebot2

Features

• Multi-Platform Chatbot Development - Provides a framework for building chatbot backends that operate across multiple messaging platforms from a single codebase.
• Chatbot Frameworks - Provides an asynchronous Python framework for building event-driven chatbots across multiple messaging platforms.
• Plugin Package Loading - Enables the discovery and importing of third-party Python packages as modular extensions to add new capabilities.
• Protocol Abstraction Layers - Standardizes diverse messaging protocols into a consistent internal event format using an abstraction layer.
• Asyncio Frameworks - Built around the Python asyncio event loop to execute multiple event handlers concurrently without stalling.
• Chat Platform Adapters - Provides a driver-based adapter system that unifies different messaging protocols into a single consistent interface.
• Dependency Injection Containers - Features a runtime system that automatically resolves and injects required objects into handlers to promote loose coupling.
• Event Bus Architectures - Features a non-blocking event pipeline that dispatches messages and system events using Python asyncio.
• Dependency Injection - Implements a type-annotation based dependency injection system to automatically provide service objects to event handlers.
• Type-Hint Injection Systems - Resolves and injects required service objects into handler functions at runtime based on Python type hints.
• Event Handler Injection - Automatically injects required service objects into asynchronous event handlers to eliminate manual wiring boilerplate.
• Chat Interface Adapters - Implements a unified interface and adapters to manage events and responses across various messaging platforms.
• Third-Party Plugins - Extends system functionality by installing and activating community or custom extension packages.
• Non-Blocking Event Loops - Uses a non-blocking event loop to dispatch messages through a central pipeline for concurrent handler execution.
• Plugin-Based Architectures - Utilizes a modular plugin architecture for the discovery and loading of third-party extensions to add new handlers.
• Plugin-Based Architectures - Implements a modular architecture that discovers and loads external Python packages as plugins with a standardized interface.
• Conversation State Management - Tracks conversation context and per-user state to facilitate seamless multi-turn dialogue interactions.
• Session Context Retention - Maintains per-conversation state and context across multiple events to enable complex multi-turn interactions.
• Thread-Pooled - Offloads blocking synchronous functions to a separate worker thread pool to prevent freezing the main async loop.
• Event Filtering Rules - Evaluates event-matching rules through a chain of filters to route messages to the correct handlers.
• Protocol Action Adapters - Separates platform-specific communication logic into interchangeable adapters that map to internal protocol actions.
• Event Routing Matchers - Filters events through a chain of rule-based matchers to determine the appropriate handler for each message.
• Asynchronous Processing - Processes multiple concurrent interactions using non-blocking execution to maintain high system responsiveness.
• Modular Extension Architectures - Allows adding or removing specific feature sets through a modular architecture to manage capabilities independently.

Star history