d8643a309a
The browser lives at /docker/falkordb-browser/ on the host (separate from the MiroFish stack so they can be restarted independently). It joins the mirofish_net bridge network as 'external' and dials the same FalkorDB sidecar the MiroFish app uses. Users sign in via the browser UI by entering host=falkordb, port=6379, empty user/pass — the connection is server-side from inside the browser container, so the user's machine doesn't need direct access to the Docker network. |
||
|---|---|---|
| .github/workflows | ||
| backend | ||
| deploy | ||
| frontend | ||
| locales | ||
| static/image | ||
| .dockerignore | ||
| .env.example | ||
| .gitignore | ||
| Dockerfile | ||
| LICENSE | ||
| README-ZH.md | ||
| README.md | ||
| docker-compose.yml | ||
| nginx.conf | ||
| package-lock.json | ||
| package.json | ||
| start.sh | ||
README.md
简洁通用的群体智能引擎，预测万物
A Simple and Universal Swarm Intelligence Engine, Predicting Anything
⚡ 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.
This is a maintained fork of 666ghj/MiroFish. It swaps Zep Cloud for Graphiti + FalkorDB (open source, self-hosted), adds a one-call
POST /api/graph/ingest_textAPI for cron automations, and ships a production Docker stack foragent.profikid.nl. See About this fork below.
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
- Graph Building: Seed extraction & Individual/collective memory injection & GraphRAG construction
- Environment Setup: Entity relationship extraction & Persona generation & Agent configuration injection
- Simulation: Dual-platform parallel simulation & Auto-parse prediction requirements & Dynamic temporal memory updates
- Report Generation: ReportAgent with rich toolset for deep interaction with post-simulation environment
- 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: MiniMax M-series via https://api.minimax.io/v1
# - MiniMax-M2.7-highspeed : best for cron / high-volume (recommended)
# - MiniMax-M3 : heavier reasoning, slower, higher quality
# Alibaba Qwen-plus 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://api.minimax.io/v1
LLM_MODEL_NAME=MiniMax-M2.7-highspeed
# Graph store (this fork: Graphiti + FalkorDB; no Zep API key needed)
# FalkorDB runs as a Docker sidecar — see deploy/docker-compose.yml
FALKORDB_HOST=falkordb
FALKORDB_PORT=6379
# Embedding model (local sentence-transformers, pre-downloaded in the image)
EMBEDDING_MODEL=sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2
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
# 2. Pull image and start
docker compose up -d
Reads .env from root directory by default, maps ports 3000 (frontend) / 5001 (backend)
Mirror address for faster pulling is provided as comments in
docker-compose.yml, replace if needed.
📬 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!
🔱 About this fork
This is a maintained fork of 666ghj/MiroFish maintained at profikid/MiroFish. It replaces the Zep Cloud dependency with Graphiti + FalkorDB (both open source), adds a one-call ingest API, and ships a production-ready Docker deployment for agent.profikid.nl.
What changed vs upstream
| Upstream | This fork | |
|---|---|---|
| Graph store | Zep Cloud (managed, requires API key) | Graphiti + FalkorDB (self-hosted, Redis protocol) |
| LLM recommendation | Qwen-plus (DashScope) | MiniMax M-series (M2.7-highspeed for cron, M3 for high-quality) |
| Ingest API | 3 calls (project → ontology → build) | 1 call: POST /api/graph/ingest_text (project + ontology + build) |
| Deploy | npm run dev (dev) / docker compose up (Docker Hub) |
deploy/ overlay: Traefik + Let's Encrypt + FalkorDB sidecar + e2e one-shot |
| E2E test | none shipped | deploy/e2e_test.py + deploy/e2e.sh (builds a one-shot image, runs against the real briefing seed) |
| Cron-friendly | not designed for it | deploy/mirofish_ingest.sh — one-shot POST + poll, exits 0/2/3/4 |
| Embeddings | Zep-managed | local sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2 (pre-downloaded in the image) |
Why Graphiti + FalkorDB
Zep Cloud's free tier is fine for dev, but for a self-hosted cron pipeline (Iran briefing every 12h, entity extraction, simulations) you want:
- No per-month API cap — the cron keeps running on bad days, good days, news spikes
- No external service dependency — graph store lives next to the app as a Docker sidecar
- Same engine — Graphiti is the open-source core that powers Zep Cloud, so the entity/edge quality is identical
The backend/app/services/graphiti_service.py shim is a Zep-shaped facade over a real Graphiti(graph_driver=FalkorDriver(...)), so the rest of the MiroFish codebase (which still speaks Zep) didn't have to change.
Production deployment
The deploy/ directory contains a single-host Docker stack for agent.profikid.nl:
# On the host:
cd /docker/mirofish
./deploy/up.sh # build image, bring up mirofish + falkordb
./deploy/e2e.sh # run the e2e test against the real briefing seed
Traefik (already on the host) auto-issues the Let's Encrypt cert for mirofish.agent.profikid.nl. See deploy/README.md for the full layout, env vars, and troubleshooting.
Cron integration
The fork was built so that a scheduled OSINT briefing cron can drop the markdown output straight into MiroFish:
# Cron's last-written briefing file -> POST + poll
briefing="$(ls -t /home/hermes/.hermes/cron/output/<job_id>/*.md | head -1)"
nohup bash /docker/mirofish/deploy/mirofish_ingest.sh \
"iran-osint-$(date -u +%Y%m%dT%H%M)" \
"$briefing" \
>/tmp/mirofish-ingest.log 2>&1 &
The script handles ontology generation + async graph build + polling, exits 0 on success with a nodes=N edges=M summary in the log.