简洁通用的群体智能引擎，预测万物
A Simple and Universal Swarm Intelligence Engine, Predicting Anything

English | 中文文档

⚡ Overview

MiroFish is a next-generation AI prediction engine powered by multi-agent technology. By extracting seed information from the real world (such as breaking news, policy drafts, or financial signals), it automatically constructs a high-fidelity parallel digital world. Within this space, thousands of intelligent agents with independent personalities, long-term memory, and behavioral logic freely interact and undergo social evolution. You can inject variables dynamically from a "God's-eye view" to precisely deduce future trajectories — rehearse the future in a digital sandbox, and win decisions after countless simulations.

You only need to: Upload seed materials (data analysis reports or interesting novel stories) and describe your prediction requirements in natural language
MiroFish will return: A detailed prediction report and a deeply interactive high-fidelity digital world

Our Vision

MiroFish is dedicated to creating a swarm intelligence mirror that maps reality. By capturing the collective emergence triggered by individual interactions, we break through the limitations of traditional prediction:

• At the Macro Level: We are a rehearsal laboratory for decision-makers, allowing policies and public relations to be tested at zero risk
• At the Micro Level: We are a creative sandbox for individual users — whether deducing novel endings or exploring imaginative scenarios, everything can be fun, playful, and accessible

From serious predictions to playful simulations, we let every "what if" see its outcome, making it possible to predict anything.

🌐 Live Demo

Welcome to visit our online demo environment and experience a prediction simulation on trending public opinion events we've prepared for you: mirofish-live-demo

📸 Screenshots

🎬 Demo Videos

1. Wuhan University Public Opinion Simulation + MiroFish Project Introduction

Click the image to watch the complete demo video for prediction using BettaFish-generated "Wuhan University Public Opinion Report"

2. Dream of the Red Chamber Lost Ending Simulation

Click the image to watch MiroFish's deep prediction of the lost ending based on hundreds of thousands of words from the first 80 chapters of "Dream of the Red Chamber"

Financial Prediction, Political News Prediction and more examples coming soon...

🔄 Workflow

1. Graph Building: Seed extraction & Individual/collective memory injection & GraphRAG construction
2. Environment Setup: Entity relationship extraction & Persona generation & Agent configuration injection
3. Simulation: Dual-platform parallel simulation & Auto-parse prediction requirements & Dynamic temporal memory updates
4. Report Generation: ReportAgent with rich toolset for deep interaction with post-simulation environment
5. Deep Interaction: Chat with any agent in the simulated world & Interact with ReportAgent

🚀 Quick Start

Option 1: Source Code Deployment (Recommended)

Prerequisites

Tool	Version	Description	Check Installation
Node.js	18+	Frontend runtime, includes npm	node -v
Python	≥3.11, ≤3.12	Backend runtime	python --version
uv	Latest	Python package manager	uv --version

1. Configure Environment Variables

# Copy the example configuration file
cp .env.example .env

# Edit the .env file and fill in the required API keys

Required Environment Variables:

# LLM API Configuration (supports any LLM API with OpenAI SDK format)
# Recommended: Alibaba Qwen-plus model via Bailian Platform: https://bailian.console.aliyun.com/
# High consumption, try simulations with fewer than 40 rounds first
LLM_API_KEY=your_api_key
LLM_BASE_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
LLM_MODEL_NAME=qwen-plus
# Optional: per-process request concurrency caps. Lower these when the provider
# slows down under burst traffic.
# LLM_MAX_CONCURRENT_REQUESTS=2
# Optional HTTP tuning for OpenAI-compatible providers / proxies.
# `auto` (default) disables keep-alive reuse for non-OpenAI endpoints and helps
# avoid intermittent 502/provider_connection_failed errors from stale pooled connections.
# LLM_CONNECTION_CLOSE=auto
# LLM_MAX_RETRIES=5
# LLM_REQUEST_TIMEOUT_SECONDS=600
# LLM_CONNECT_TIMEOUT_SECONDS=10
# Optional: dedicated model for Graphiti graph build (defaults to LLM_MODEL_NAME)
# GRAPHITI_LLM_MODEL_NAME=qwen-turbo
# Optional: Graphiti extraction/rerank concurrency cap
# GRAPHITI_LLM_MAX_CONCURRENT_REQUESTS=2

# Knowledge graph: Graphiti + FalkorDB (self-hosted, replaces Zep Cloud)
# With docker-compose, FalkorDB starts automatically and the backend is wired to it.
# For local (non-docker) runs, start FalkorDB yourself (with increased query timeout):
#   docker run -p 6379:6379 -e FALKORDB_ARGS="TIMEOUT_DEFAULT 30000 TIMEOUT_MAX 60000" falkordb/falkordb
GRAPH_DB_HOST=localhost
GRAPH_DB_PORT=6379
GRAPH_DB_NAME=mirofish

# Embeddings (Graphiti needs a vector embedder; defaults reuse the LLM creds).
# EMBEDDER_DIM must match the model: OpenAI text-embedding-3-small=1536, Alibaba text-embedding-v3=1024
EMBEDDER_MODEL_NAME=text-embedding-3-small
# Optional: embedder request concurrency cap
# EMBEDDER_MAX_CONCURRENT_REQUESTS=4
EMBEDDER_DIM=1536

Note: The knowledge graph is now fully self-hosted via FalkorDB + Graphiti. No external Zep Cloud account/API key is required. When using docker compose up, the falkordb service is started and persisted automatically.

2. Install Dependencies

# One-click installation of all dependencies (root + frontend + backend)
npm run setup:all

Or install step by step:

# Install Node dependencies (root + frontend)
npm run setup

# Install Python dependencies (backend, auto-creates virtual environment)
npm run setup:backend

3. Start Services

# Start both frontend and backend (run from project root)
npm run dev

Service URLs:

• Frontend: http://localhost:3000
• Backend API: http://localhost:5001

Start Individually:

npm run backend   # Start backend only
npm run frontend  # Start frontend only

Option 2: Docker Deployment

# 1. Configure environment variables (same as source deployment)
cp .env.example .env
# IMPORTANT: set a strong SECRET_KEY in .env (required in production mode)

# 2. Build and start (frontend via nginx, backend via gunicorn)
docker compose up -d --build

Reads .env from the root directory by default. Only the frontend is published on the host at http://localhost:3000; it serves the production-built SPA and reverse-proxies /api to the backend over the internal network, so the backend port is not exposed externally.

Production hardening notes:

• Backend runs under gunicorn (not the Flask dev server); the Werkzeug debugger is off by default (FLASK_DEBUG=false).
• SECRET_KEY is required in production; the container refuses to start without it.
• CORS is closed by default (same-origin via nginx). Override with CORS_ORIGINS (comma-separated, or *) only if you call the API cross-origin.
• Frontend is a minified static build. Gunicorn defaults to one worker and one thread to avoid backend request concurrency; tune via GUNICORN_WORKERS / GUNICORN_THREADS / GUNICORN_TIMEOUT only after validating concurrent workloads.

GPU acceleration (optional)

The backend image ships CPU-only PyTorch by default to keep the image small (it avoids multi-GB NVIDIA CUDA packages). PyTorch is only an indirect dependency (via camel-oasis → sentence-transformers) used for embeddings, so CPU is fine for most users.

If you run on a host with an NVIDIA GPU and want acceleration:

# 1. Build the backend with a CUDA build of torch (match your CUDA: cu121 / cu124 / cu126)
TORCH_VARIANT=cu124 docker compose build backend

# 2. Install nvidia-container-toolkit on the host, then uncomment the
#    `deploy.resources.reservations.devices` block under the backend service in docker-compose.yml

# 3. Start
docker compose up -d

Without these steps a CUDA image still falls back to CPU, so the lightweight CPU default is recommended unless you specifically need GPU.

📬 Join the Conversation

 

The MiroFish team is recruiting full-time/internship positions. If you're interested in multi-agent simulation and LLM applications, feel free to send your resume to: mirofish@shanda.com

📄 Acknowledgments

MiroFish has received strategic support and incubation from Shanda Group!

MiroFish's simulation engine is powered by OASIS (Open Agent Social Interaction Simulations), We sincerely thank the CAMEL-AI team for their open-source contributions!

📈 Project Statistics