convez.ai
MCP Server
ManusAgents

ManusClaw

ManusAgents/ManusClaw

Ver no GitHub
BomPluginScore · de 0 a 100

Manusclaw: Unleash self-reasoning CLI beasts to execute code, browse the web, and dominate tasks — across 12+ messaging channels, with voice wake, live canvas, SSH control, and multi-agent routing. No limits. Pure power.

Instalação

$npx convez-ai ManusAgents/ManusClaw

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
5
Forks
8
Acompanhando
0
Saúde
87%
Último commit
há 3 meses
Versão
—
Issues abertas
1
Contribuidores
4

README

A tradução para o português deste README ainda está na fila.

🐾 M A N U S C L A W

v5.1.0 — Enterprise-Grade Autonomous AI Agent Framework

A production-ready, self-reasoning AI agent framework with PAORR loop, DAG-based multi-agent orchestration, defense-in-depth security, 100+ LLM providers (cloud + offline/GGUF/HuggingFace), 13+ messaging channels, voice interaction, live canvas, SSH server, cron scheduler, and enterprise observability.


Table of Contents


🆕 What's New in v5.1

ManusClaw v5.1 introduces enterprise-grade capabilities that transform it from a powerful agent framework into a production-ready AI operations platform.

CategoryHighlights
Event System17 discriminated union event types, LLMConvertibleEvent, file-backed EventLog with O(1) length, crash-proof atomic writes
SecurityDefense-in-depth: Pattern + Policy Rails + LLM + Ensemble analyzers with max-severity fusion
Hooks6 lifecycle event types, DENY/MODIFY/ALLOW decisions, audit trail, per-hook timeout
ContextView system with manipulation indices, LLMSummarizingCondenser, property enforcement
ConversationLocal & Remote modes, StuckDetector (5 patterns), CancellationToken, FIFOLock
Parallel ExecutionResourceLockManager with readers-writer locking, deadlock prevention
LLM100+ providers via litellm, streaming deltas, model failover, non-native tool calling
SecretsFernet-encrypted store, SecretRegistry with lazy resolution, audit logging
File StoragePluggable backends: Local, S3, GCS, In-Memory with factory auto-detection
Git ProvidersGitHub, GitLab, Azure DevOps, Bitbucket, Forgejo — unified provider interface
Issue ResolutionLLM-powered resolver for issues, PRs, merge conflicts with webhook triggers
Project MgmtJira, Linear, Slack integrations for task tracking and notifications
ObservabilityOpenTelemetry tracing, Prometheus metrics, K8s liveness + readiness probes
MigrationsAlembic database migrations with 7 core tables

🌟 Overview

ManusClaw is an enterprise-grade autonomous AI agent framework that empowers Large Language Models to plan, execute code, browse the web, manage files, resolve issues, and complete complex multi-step tasks — all autonomously.

At its core is the PAORR reasoning loop (Plan → Act → Observe → Reflect → Retry), a self-correcting execution model. Combined with DAG-based multi-agent orchestration, defense-in-depth security, offline LLM support (GGUF/HuggingFace/Ollama), and enterprise observability, ManusClaw runs anywhere — cloud, local, or fully air-gapped.

Why ManusClaw?

ChallengeManusClaw Solution
Vendor lock-in100+ cloud providers + offline GGUF/HuggingFace/Ollama with credential rotation and model failover
No internet accessFully offline: GGUF via llama-cpp-python, HuggingFace local, Ollama local — zero cloud dependency
No persistenceSQLite-backed sessions, event logs, task queues — all survive restarts
Security blind spotsDefense-in-depth: Pattern → Rails → LLM → Ensemble with audit trails
Single-agent limitDAG-based Multi-Agent Orchestrator with per-channel/per-account routing
Context overflowView system with LLM Summarizing Condenser and property enforcement
Tool chaosHeuristic + LLM ToolSelector scores 17+ tools with failure penalties
Platform fragmentation13+ messaging adapters, voice, canvas, SSH, webhooks, cron
No observabilityOpenTelemetry, Prometheus metrics, K8s health probes, correlation IDs
Secret managementFernet encryption, SecretRegistry with lazy resolution

🏗️ Architecture

┌─────────────────────────────────────────────────────────────────────────────┐
│                          PRESENTATION LAYER                                 │
│  CLI · WebChat · Canvas (A2UI) · SSH Server · 13+ Messaging · Voice        │
│  Desktop: macOS Menubar · Windows Hub · Mobile Node Client                  │
├─────────────────────────────────────────────────────────────────────────────┤
│                           AGENT LAYER                                       │
│  ┌──────────────┐  ┌───────────────┐  ┌─────────────────────────────────┐  │
│  │  PAORR Loop  │  │  Multi-Agent  │  │  Role Pipeline                  │  │
│  │ Plan → Act → │  │  Orchestrator │  │  PM → Architect → Engineer → QA │  │
│  │ Observe →    │  │  (DAG-based)  │  │  with RoleMessageBus            │  │
│  │ Reflect →    │  └───────────────┘  └─────────────────────────────────┘  │
│  │ Retry        │                                                         │
│  └──────────────┘                                                         │
├─────────────────────────────────────────────────────────────────────────────┤
│                         MIDDLEWARE LAYER                                    │
│  Hooks · Security Ensemble · Context View + Condenser · Conversation       │
│  Parallel Executor (ResourceLock) · Event System (Discriminated Unions)    │
├─────────────────────────────────────────────────────────────────────────────┤
│                        INTEGRATION LAYER                                    │
│  LLM (100+ cloud + GGUF/HF/Ollama offline) · Git Providers (5 platforms)  │
│  Issue Resolver · Project Mgmt (Jira/Linear/Slack) · Secrets (Fernet)     │
│  File Storage (S3/GCS/Local) · MCP Protocol · Observability (OTEL/Prom)   │
├─────────────────────────────────────────────────────────────────────────────┤
│                          TOOL LAYER (17+)                                   │
│  Bash · Python · Node.js · Browser · WebSearch · Crawl4AI · ImageGen      │
│  StrReplace · Memory · Delegate · Planning · DataViz · AskHuman           │
│  PlatformCtrl · SkillManager · CrossSessionSearch · Terminate · Selector   │
├─────────────────────────────────────────────────────────────────────────────┤
│                       INFRASTRUCTURE LAYER                                  │
│  SQLite WAL · SessionDB (FTS5) · Cron Scheduler · TaskQueue · Sandbox     │
│  (Docker/SSH/OpenShell) · Alembic Migrations · LongTermMemory             │
└─────────────────────────────────────────────────────────────────────────────┘

✨ Features

🤖 Agent System — PAORR Loop + Multi-Agent + Roles

The PAORR loop is the heart of ManusClaw — a self-correcting reasoning cycle that plans, acts, observes, reflects, and retries until the task is complete.

FeatureDescription
PAORR LoopPlan → Act → Observe → Reflect → Retry — autonomous self-correction at every step
Self-CheckManus agent performs self-check every 3 steps to verify progress
Multi-Agent OrchestratorDAG-based pipeline with topological sorting (Kahn's algorithm), event hooks, global timeout
Role PipelineProductManager → Architect → Engineer → QA with typed RoleResult and RoleMessageBus
Agent RouterPer-channel and per-account routing with LRU cache (64 entries, 300s idle TTL)
Agent RegistryDynamic agent class import (sandboxed to app. namespace) with idle eviction + cleanup
Identity Guard30+ anti-jailbreak patterns in 9 languages (English, Chinese, Spanish, French, German, Portuguese, Japanese, Korean, Russian)
Permission Gate3-tier access control: AUTONOMOUS / CONFIRM / RESTRICTED with catastrophic pattern blocking
Skill EngineAuto-injection of domain expertise from Markdown skill files based on relevance matching
PlanningFlowStep-by-step task decomposition with scoring, replanning, and agent caching

Agent Types:

AgentDescription
ManusFull-featured autonomous agent with all 14+ tools, PAORR loop, self-check every 3 steps
ReActThink → Act → Observe → Reflect → Retry loop with max 3 reflect retries per step
ToolCallStructured function-calling agent with ToolSelector scoring and permission gate
BrowserBrowser-focused agent (browser, search, crawl, terminate)
DataAnalysisManus + DataVisualization tool for data exploration workflows
MCPConnects to MCP servers (stdio/SSE) and proxies their tools

Agent Inheritance: BaseAgent → ReActAgent → ToolCallAgent → Manus → DataAnalysisAgent

📡 Event System — Discriminated Unions + EventLog

FeatureDescription
17 Event TypesSystemPrompt, Message, Action, Observation, Condensation, CondensationRequest, AgentError, Token, Interrupt, Pause, ConversationError, StateUpdate, LLMCompletionLog, HookExecution, StreamingDelta, UserRejectObservation, ResumeTranscript
Discriminated UnionsType-safe polymorphism via kind literal discriminators for pattern matching
LLMConvertibleEventProtocol for events that convert to LLM message format with parallel tool-call batching
File-Backed EventLogNDJSON append-only log with O(1) length queries, lazy loading, atomic writes
Crash SafetyTemp-file-then-rename strategy; count file updated post-write; reindex() recovery
JSON SerializationFull serialize/deserialize with serialize_batch() / deserialize_batch() for NDJSON

🛡️ Security Defense-in-Depth

Multi-layer security analysis combining pattern matching, policy rails, LLM-based analysis, and ensemble fusion.

LayerClassDescription
Pattern AnalyzerPatternSecurityAnalyzer8 regex patterns across 2 corpora (executable + all-field): rm_rf, sudo_rm, eval_call, subprocess, curl_pipe_exec, inject_override, inject_mode_switch, inject_identity
Policy RailsPolicyRailSecurityAnalyzer3 structural rails: fetch-to-exec, raw-disk-op, catastrophic-delete. Per-segment evaluation prevents cross-field false positives
LLM AnalyzerLLMSecurityAnalyzerAI-powered semantic analysis for subtle threats, configurable call budget
Ensemble AnalyzerEnsembleSecurityAnalyzerCombines all analyzers with max-severity fusion, crash isolation, full audit trail
Confirmation PolicyNeverConfirm / ConfirmRiskyHuman-in-the-loop confirmation for HIGH/UNKNOWN risk operations
Cipher ModuleCipherFernet-based encryption for data at rest with key rotation support
Secret Redactionredact()Context-aware detection and masking of API keys, tokens, AWS secrets with prefix preservation

🪝 Hooks System

Event TypeWhenCan Block?
SESSION_STARTAgent session beginsNo
USER_PROMPT_SUBMITBefore user prompt enters loopYes (DENY/MODIFY)
PRE_TOOL_USEBefore tool executionYes (DENY)
POST_TOOL_USEAfter tool returnsNo
STOPAgent about to stopYes (DENY)
SESSION_ENDSession terminatesNo

Built-in Hooks: LoggingHook (logs all events), SecurityHook (integrates with security analyzers and blocks dangerous actions), AuditHook (JSONL audit trail with secret sanitization).

Hook Loading: YAML config with class_path imports, Python module auto-discovery from manusclaw home directory.

🧠 Context Management — View + Condenser

FeatureDescription
View SystemLinear event projection with manipulation_indices — safe points for condensation
View PropertiesBatchAtomicity, ObservationUniqueness, ToolCallMatching, ToolLoopAtomicity — structural integrity guarantees
LLM Summarizing CondenserDedicated condenser LLM generates summaries of removed events; 3 trigger reasons: REQUEST (hard), TOKENS (soft), EVENTS (soft)
Rolling Window CondenserKeeps the N most recent events, drops the rest
Pipeline CondenserChains multiple condensers with stop_on_first short-circuit and aggregated metrics
Progressive TruncationIf condenser LLM fails, progressively truncates with retry scaling (5 retries, 0.8x per retry)
No-op CondenserPass-through for when condensation is disabled

💬 Conversation System

FeatureDescription
Local ConversationIn-process conversation with event log, async support, fork/branch, confirmation mode
Remote ConversationWebSocket-backed conversation for distributed deployments with reconnection + event buffering
StuckDetector5 detection patterns: repeating action-observation, action-error loops, agent monologue, alternating patterns, context window overflow
CancellationTokenThread-safe cancellation with raise_if_cancelled(), timeout support, context manager
FIFOLockFair, starvation-free lock (sync + async variants) guaranteeing FIFO ordering
Conversation FactoryAuto-creates Local or Remote based on configuration

⚡ Parallel Tool Execution

FeatureDescription
ResourceLockManagerReaders-writer locking per resource with deadlock prevention via global acquisition ordering
Declared ResourcesEach tool declares READ/WRITE dependencies: file_resource(), terminal_resource(), network_resource()
ParallelToolExecutorThread-pool concurrent execution with resource conflict serialization
AsyncParallelToolExecutorasyncio.gather variant with semaphore for concurrency capping
MetricsExecution time, concurrency level, resource conflicts, per-tool timeout

🧠 LLM Integration — 100+ Providers + Offline + Streaming

Cloud Providers

ProviderClassAuth
OpenAINative SDKOPENAI_API_KEY (supports _2, _3 for pool)
AnthropicNative SDKANTHROPIC_API_KEY
Google/Geminigoogle-generativeaiGOOGLE_API_KEY
MistralMistralClientMISTRAL_API_KEY
AWS BedrockBedrockClient (Converse API)AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY
100+ via litellmLiteLLMClientVaries per provider

Offline / Local / Air-Gapped Providers

ProviderClassDetails
GGUFGGUFRouterllama-cpp-python, fully offline, GPU support (n_gpu_layers), tool-call parsing from text
OllamaOllamaRouterOfficial SDK, local + Ollama Cloud with API key
LMStudioOpenAICompatRouterOpenAI-compatible endpoint at localhost:1234
text-gen-webuiOpenAICompatRouterOpenAI-compatible endpoint at localhost:5000
HuggingFaceHuggingFaceRouterInference API + Spaces + Dedicated Endpoints
Any OpenAI-compatOpenAICompatRouterGeneric REST endpoint (Groq, Together, etc.)
MockMockLLMNo API key needed, safe for immediate testing

Pre-Configured Provider TOMLs

Config FileServiceType
ollama.tomlOllama (local)Free / Local
ollama-cloud.tomlOllama CloudPaid / API
openrouter.tomlOpenRouter (200+ models)Paid / API
pollinations.tomlPollinations AIFree / No key needed
7llm.toml7LLMPaid / API
opencode.tomlOpenCode (deepseek-v4-flash-free)Free / No key needed

LLM Infrastructure

FeatureDescription
Credential PoolPer-provider multi-key rotation with priority ordering, cooldown, and health tracking. Supports OPENAI_API_KEY_2, _3, etc.
Cross-Provider RotatorCrossProviderRotator — unified credential interface across all providers
Profile RotationProfileRotator — ordered model entries with priority, fallback weights, per-session profile selection, bounded cache
Fallback StrategyConfigurable model chains with per-model cooldown, 8 fallback triggers (rate_limit, context_window, timeout, etc.)
StreamingToken-level streaming with StreamingDeltaEvent, SSE for web clients, backpressure handling, multi-provider chunk parsing
Enhanced Retry5 backoff strategies (fixed, linear, exponential, exponential_jitter, decorrelated_jitter), retry budgets, provider-specific error mapping
Token BudgetPer-session token tracking with grace call support and cost estimation
LLM MetricsPer-conversation cost tracking, latency percentiles (p50/p95/p99), budget alerts, Prometheus export
Non-Native Tool CallingNonNativeToolCallingMixin — emulates function calling for models without native support via prompt engineering + JSON extraction
Secret RedactionContext-aware masking of API keys, Bearer tokens, AWS secrets in prompts and logs

🔐 Secrets Management — Fernet Encryption

FeatureDescription
Fernet EncryptionSymmetric encryption for secrets at rest with FERNET_TOKEN_PREFIX identifier
SecretRegistryNamed registry with lazy resolution from backing store, namespaces, caching
File Secrets StoreEncrypted file-based storage with atomic writes and 0600 permissions
Secret SourcesSTATIC (provided value), LOOKUP (fetched from URL), ENV (from environment variable)
API RouterFastAPI /secrets endpoints — never exposes raw values (masked with ***)
Key RotationCipher supports key rotation with add_key() for seamless rotation

📦 File Storage Backends

BackendUse CaseKey Feature
LocalFilesystem storage (default)Atomic writes, sidecar .meta.json, streaming
S3AWS S3 / MinIOPresigned URLs, retry with backoff, async executor
GCSGoogle Cloud StorageSigned URLs (v4), retry with backoff, async executor
In-MemoryTesting and ephemeralFull metadata tracking, size limits

Factory auto-detection from MANUSCLAW_FILE_STORE_BACKEND env var, config, or explicit parameter.

🔀 Git Provider Integrations

ProviderOAuthPRs/MRsIssuesBranchesFilesSuggested TasksWebhooks
GitHub✅✅✅✅✅✅✅
GitLab✅✅✅✅✅✅✅
Azure DevOps✅✅✅ (Work Items)✅✅✅✅
Bitbucket✅✅✅✅✅✅✅
Forgejo✅✅✅✅✅✅✅

All providers implement a unified GitProviderService interface with both sync and async methods, thread-safety, rate limiting, and exponential backoff.

Suggested Task Types: OPEN_ISSUE, FAILING_CHECKS, MERGE_CONFLICT, UNRESOLVED_COMMENTS

Git Provider Router — URL-based provider detection (10+ URL patterns including self-hosted instances) with service caching.

🎯 Issue & PR Resolution

LLM-powered automated resolution for issues, PRs, and merge conflicts.

Resolution TypeDescription
Issue ResolutionAnalyze reported issue → generate fix → apply changes → post summary comment
PR UpdateProcess review feedback → update code → respond to comments
Merge Conflict ResolutionDetect conflicts → resolve with LLM assistance → push resolution
Comment ResponseReply to issue/PR comments with context-aware responses

Features: Thread-safe with per-resolution locking, timeout protection, full audit trail, concurrency semaphore (max 5), Jinja2 prompt templates per provider.

Webhook Handler: HMAC-SHA256 signature verification, event deduplication, background processing with retry, provider-specific payload normalization.

📋 Project Management — Jira + Linear + Slack

IntegrationCapabilities
Jira Cloud + DCOAuth/PAT auth, create/update/search issues, JQL search, comments, transitions, ADF to text, webhooks
LinearGraphQL API, OAuth 2.0, teams, issues, comments, suggested tasks, webhooks
SlackSocket Mode + API, slash commands (/manusclaw, /resolve, /review), Block Kit, thread conversations, interactive buttons, file uploads

📊 Observability — OpenTelemetry + Prometheus

ComponentDescription
OpenTelemetry Tracing@observe decorator for sync/async functions, context propagation, custom span attributes (model, tokens, tool_name)
Prometheus MetricsCounters, histograms, gauges for LLM calls, tool execution, conversations, tokens, errors
Health ProbesKubernetes-style liveness (/healthz) and readiness (/ready) with component checkers
Component CheckersDatabaseHealthChecker, LLMHealthChecker, SandboxHealthChecker
Correlation IDsRequest-scoped correlation ID propagation across service boundaries, error_id for 500 error lookup
Structured LoggingJSON-structured logs with context enrichment and sensitive data redaction
Metrics ExportPrometheus exposition format, JSON dict format

Built-in Metrics: llm_calls_total, llm_call_duration_seconds, tool_calls_total, tool_call_duration_seconds, conversation_duration_seconds, active_conversations, token_usage_total, error_count_total

📨 13+ Messaging Channels

ChannelTypeKey Feature
TelegramBot APIInline keyboards, file handling, media messages
DiscordBotSlash commands, embeds, thread support
SlackBolt SDKBlocks, modals, events, interactive components
WhatsAppBusiness APIMedia messages, templates, read receipts
SignalCLIEnd-to-end encrypted messaging
Microsoft TeamsBot FrameworkAdaptive cards, tabs, channel messages
MatrixProtocolFederation, E2E encryption, rooms
IRCClientMulti-network, channels, CTCP
TwitchChatStream integration, commands
Google ChatWebhookSpaces, threads, cards
WebChatBuilt-inWebSocket, real-time, canvas integration
EmailSMTP/IMAPSend/receive, Gmail Pub/Sub auto-reply
Messaging GatewayUnifiedMulti-adapter routing, agent caching, eviction with cleanup

🎤 Voice System — Wake Word + STT + TTS

FeatureDescription
Wake Word DetectionPvporcupine or STT-based wake word ("Hey ManusClaw")
Talk ModeContinuous mic → STT → agent → TTS conversation loop
Text-to-Speech3 backends: OpenAI TTS, ElevenLabs, System TTS (espeak/piper)
Speech-to-Text3 engines: OpenAI Whisper, Google STT, Vosk (fully offline)

🎨 Canvas UI — A2UI Protocol

FeatureDescription
A2UI ProtocolReal-time WebSocket updates from agent to browser with typed component model
Canvas ServerBuilt-in WebSocket server for live rendering
Canvas ToolAgent tool for rendering charts, tables, buttons, text, images, containers
Chart TypesBar, line, scatter, pie, histogram, area, radar
Component TypesText, Image, Button, Table, Chart, Container — composable UI
Mobile NodesConnect mobile devices as canvas nodes
Static HTMLStandalone canvas.html for quick deployment

🛠️ 17+ Tools — Intelligent Selector

#ToolCategoryDescription
1BashExecutionPersistent async shell (Linux/macOS/Windows/Termux). No artificial timeout. Only OS-destroying commands blocked. Atexit cleanup for orphaned processes.
2PythonExecuteExecutionIsolated subprocess (2GB memory rlimit on Linux). No default timeout. Full stdout/stderr capture.
3NodeExecuteExecutionExecute Node.js/JavaScript in isolated subprocess
4StrReplaceEditorFilesView, create, str_replace, insert, undo_edit — precise file operations
5BrowserUseWebPlaywright browser: navigate, click, type, screenshot, get_text, execute_js, tabs
6WebSearchWebMulti-engine search: DuckDuckGo → Bing fallback with retry
7Crawl4AIWebExtract clean content from URLs (crawl4ai or aiohttp fallback)
8ImageGenerateCreativeGenerate images via FAL.ai (or mock). Saves to workspace/images/
9DataVisualizationAnalysisGenerate charts (bar, line, scatter, pie, histogram). PNG or HTML with mpld3.
10MemoryKnowledgeCRUD for MEMORY.md and USER.md — persistent context files across sessions
11PlanningPlanningCreate/update/mark_step/get multi-step execution plans
12DelegateMulti-AgentSpawn isolated subagent (Manus instance) for independent subtasks
13AskHumanInteractionRequest clarification from user (interactive mode only)
14PlatformControlSystemAuthenticate and control external platforms: GitHub, Vercel, WordPress, HuggingFace, Netlify, Discord, Telegram, generic REST
15SkillManagerSkillsCreate/patch/delete/list/get skill files
16CrossSessionSearchKnowledgeFTS5 full-text search across all past sessions
17TerminateControlSignal task completion

Tool Selector — Confidence-based tool scoring (0.0–1.0) with heuristic keyword matching, optional LLM scoring, failure penalty, recency diversification, and public stats API.

📡 SSH Server

FeatureDescription
Remote AccessFull SSH server for remote agent control and task execution
Shell IntegrationInteractive shell with agent commands via SSH
ConfigurablePort, host, and authentication via config.toml or env vars

⏰ Cron Scheduler

FeatureDescription
YAML PersistenceCron jobs persisted to YAML with auto-reload
Webhook DeliveryJob results delivered via webhooks
Multi-Platform OutputResults posted to messaging channels
Auto-CleanupAgent cleanup after each job execution (no resource leaks)
Secret ProtectionWebhook secrets redacted in storage, loaded from env var

🧩 Skills Engine

Built-in skills auto-injected based on relevance to the current task:

SkillFileDomain
Codingcoding.mdSoftware development, debugging, code review
DevOpsdevops.mdCI/CD, Docker, Kubernetes, deployment
Data Analysisdata_analysis.mdPandas, statistics, data exploration
Researchresearch.mdWeb research, summarization, fact-checking
MLOpsmlops.mdMachine learning pipelines, model training
GitHubgithub.mdRepository management, PR/Issue workflows

🔌 MCP Protocol — Client + Server

FeatureDescription
MCP ClientConnect to MCP servers via stdio or SSE, proxy their tools into the agent
MCP ServerExpose manusclaw tools as MCP-compatible server
Tool ProxyingMCP tools become native manusclaw tools with full schema conversion
Auto-DiscoveryConfigure MCP servers in config.toml with auto-connect

🖥️ Desktop Apps

AppPlatformDescription
macOS MenubarmacOSSystem tray menubar app via rumps
Windows HubWindowsDesktop hub for managing manusclaw instances
Mobile NodeiOS/AndroidConnect mobile devices as canvas nodes

💾 Session & Memory System

FeatureDescription
SessionDBSQLite WAL with FTS5 full-text search, session branching, compression
Session ResumeResume interrupted sessions with /resume command
Session BranchingFork sessions with /branch for parallel exploration
Long-Term MemoryRAG-like persistent memory with FTS5 + LIKE fallback, SQLite WAL
Short-Term MemoryConversation buffer with refresh, snapshot, and restore
Task QueuePersistent SQLite task queue with priority ordering, checkpoint/resume, worker pool, deduplication
Alembic Migrations7 core tables: conversations, events, sessions, tasks, credentials, secrets, audit_log

🚀 Quick Start

Prerequisites

  • Python 3.11+
  • At least one LLM API key (or use free Pollinations/OpenCode providers — no key needed!)
  • Or run fully offline with GGUF/Ollama/HuggingFace — no internet needed!

Installation

# Clone the repository
git clone https://github.com/manusagents/manusclaw.git
cd manusclaw

# Install dependencies
pip install -e .

# Or install with all enterprise features
pip install -e ".[all-plus]"

# Configure your API key
cp config.toml config.toml.local
# Edit config.toml with your API keys, or set env vars:
export OPENAI_API_KEY=sk-...

# Run your first task
python main.py "Create a Python script that generates Fibonacci numbers"

Free / No API Key Required

# Use Pollinations (free, no key)
# Set in config.toml: provider = "pollinations"
# Or use OpenCode (free deepseek-v4-flash)
# Set in config.toml: provider = "opencode"

Fully Offline (Air-Gapped)

# GGUF — download any .gguf model and run with zero internet
# Set in config.toml:
#   provider = "gguf"
#   model_path = "/path/to/model.gguf"
#   n_gpu_layers = 0  # set >0 for GPU acceleration

# Ollama — run ollama serve, then:
#   provider = "ollama"
#   model = "llama3"

# HuggingFace — use Inference API, Spaces, or local models
#   provider = "huggingface"
#   model = "meta-llama/Llama-3-8B"

One-Line Install (Linux/macOS)

curl -fsSL https://raw.githubusercontent.com/manusagents/manusclaw/main/install.sh | bash

Windows

.\install.ps1

⚙️ Configuration

ManusClaw uses config.toml for all configuration. Key sections:

[llm]
model = "gpt-4o"
provider = "openai"                   # openai | anthropic | google | mistral | bedrock | ollama | gguf | huggingface | litellm | openrouter | pollinations | opencode | 7llm | mock
api_key = ""                          # Or set OPENAI_API_KEY env var
max_tokens = 4096
temperature = 0.7

[llm.streaming]
enabled = true
buffer_size = 4096

[llm.fallback]
enabled = false
chain = ["gpt-4o", "claude-3-5-sonnet-20241022", "gemini-2.0-flash"]

[agent]
max_iterations = 50
mode = "confirm"                      # autonomous | confirm | restricted

[security]
enabled = true
analyzers = ["pattern", "rails"]      # pattern | rails | llm | ensemble
confirmation_threshold = "medium"      # low | medium | high

[hooks]
enabled = true
auto_load = true
timeout_s = 30

[context]
max_events = 200
max_tokens = 128000
condenser_type = "rolling"            # rolling | llm_summarizing | noop

[conversation]
max_iterations = 30
confirmation_mode = "confirm_risky"   # never_confirm | confirm_risky
stuck_detection = true

[observability]
tracing = false
metrics = true
health_probes = true

[secrets]
backend = "file"                      # file | env
encryption_enabled = true

[file_store]
backend = "local"                     # local | s3 | gcs | memory

[git_providers]
default_provider = "github"           # github | gitlab | azure_devops | bitbucket | forgejo

[integrations]
webhooks_enabled = true
jinja_templates_dir = ""

[parallel_executor]
max_workers = 4
timeout_s = 300

[migrations]
enabled = true
auto_run = false

[sandbox]
backend = "docker"                    # docker | ssh | openshell

[ssh]
host = "0.0.0.0"
port = 2222

[voice]
wake_word = "hey manusclaw"
stt_engine = "openai"                 # openai | google | vosk (offline)
tts_engine = "openai"                 # openai | elevenlabs | system

See config.toml for the full configuration reference with all options and defaults.


🐳 Docker Deployment

Build

docker build -t manusclaw:latest .

Run CLI Agent

docker compose up

# One-shot task
docker compose run --rm manusclaw "Your task here"

Run Server Mode

docker compose --profile server up -d

Run Multi-Agent Pipeline

docker compose --profile multi up

Docker Compose Services

ServiceProfileDescription
manusclawdefaultInteractive CLI agent
serverserverFastAPI + WebSocket server on port 8765
multi-agentmultiMulti-agent pipeline runner

Environment Variables

OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GOOGLE_API_KEY=AI...
MISTRAL_API_KEY=...
AWS_ACCESS_KEY_ID=...
AWS_SECRET_ACCESS_KEY=...
MANUSCLAW_ALLOWED_ORIGINS=https://yourdomain.com

Health Checks

curl http://localhost:8765/healthz   # Liveness probe
curl http://localhost:8765/ready     # Readiness probe (checks DB, LLM, sandbox)

📟 Entry Points

ManusClaw installs several CLI commands:

CommandDescription
manusclawInteractive CLI agent with slash commands
manusclaw-serverFastAPI + WebSocket server
manusclaw-cronCron scheduler daemon
manusclaw-multiMulti-agent pipeline runner
manusclaw-sessionsSession management tool

CLI Slash Commands

CommandDescription
/model <name>Switch LLM model
/skillsList available skills
/toolsList available tools
/memoryShow memory contents
/compressCompress conversation context
/newStart new session
/resume <id>Resume interrupted session
/branchFork current session
/tasksShow background task queue
/bg <task>Run task in background

🤝 Contributing

We welcome contributions! Here's how to get started:

  1. Fork the repository
  2. Create a feature branch (git checkout -b feature/amazing-feature)
  3. Write your code with tests
  4. Run the test suite (pytest tests/)
  5. Submit a pull request

Development Setup

# Install with dev dependencies
pip install -e ".[all]"

# Run tests
pytest tests/ -v

# Run linting
ruff check app/

Code Style

  • Python 3.11+ with type hints throughout
  • Pydantic v2 models for all data structures (frozen=True where appropriate)
  • Thread-safe by default (locks on all shared state, RLock for reentrant access)
  • Docstrings on every public class and function
  • Crash-proof: atomic writes, atexit cleanup, proper resource management

📜 License

This project is licensed under the MIT License — see the LICENSE file for details.


ManusClaw v5.1.0 — Built by The-JDdev (SHS Lab)

Ver o original no GitHub

Bom para

Relacionados