Mirofish Offline Simulation

MiroFish-Offline Skill

Skill by ara.so — Daily 2026 Skills collection.

MiroFish-Offline is a fully local multi-agent swarm intelligence engine. Feed it any document (press release, policy draft, financial report) and it generates hundreds of AI agents with unique personalities that simulate public reaction on social media — posts, arguments, opinion shifts — hour by hour. No cloud APIs required: Neo4j CE 5.15 handles graph memory, Ollama serves the LLMs.

Architecture Overview

Document Input
     │
     ▼
Graph Build (NER + relationship extraction via Ollama LLM)
     │
     ▼
Neo4j Knowledge Graph (entities, relations, embeddings via nomic-embed-text)
     │
     ▼
Env Setup (generate hundreds of agent personas with personalities + memory)
     │
     ▼
Simulation (agents post, reply, argue, shift opinions on simulated platforms)
     │
     ▼
Report (ReportAgent interviews focus group, queries graph, generates analysis)
     │
     ▼
Interaction (chat with any individual agent, full memory persists)

Backend: Flask + Python 3.11 Frontend: Vue 3 + Node 18 Graph DB: Neo4j CE 5.15 (bolt protocol) LLM: Ollama (OpenAI-compatible /v1 endpoint) Embeddings: nomic-embed-text (768-dimensional, via Ollama) Search: Hybrid — 0.7 × vector similarity + 0.3 × BM25

Installation

Option A: Docker (Recommended)

git clone https://github.com/nikmcfly/MiroFish-Offline.git
cd MiroFish-Offline
cp .env.example .env

# Start Neo4j + Ollama + MiroFish backend + frontend
docker compose up -d

# Pull required models into the Ollama container
docker exec mirofish-ollama ollama pull qwen2.5:32b
docker exec mirofish-ollama ollama pull nomic-embed-text

# Check all services are healthy
docker compose ps

Open http://localhost:3000.

Option B: Manual Setup

1. Neo4j

docker run -d --name neo4j \
  -p 7474:7474 -p 7687:7687 \
  -e NEO4J_AUTH=neo4j/mirofish \
  neo4j:5.15-community

2. Ollama

ollama serve &
ollama pull qwen2.5:32b       # Main LLM (~20GB, requires 24GB VRAM)
ollama pull qwen2.5:14b       # Lighter option (~10GB VRAM)
ollama pull nomic-embed-text  # Embeddings (small, fast)

3. Backend

cp .env.example .env
# Edit .env (see Configuration section)

cd backend
pip install -r requirements.txt
python run.py
# Backend starts on http://localhost:5000

4. Frontend

cd frontend
npm install
npm run dev
# Frontend starts on http://localhost:3000

Configuration (.env)

# ── LLM (Ollama OpenAI-compatible endpoint) ──────────────────────────
LLM_API_KEY=ollama
LLM_BASE_URL=http://localhost:11434/v1
LLM_MODEL_NAME=qwen2.5:32b

# ── Neo4j ─────────────────────────────────────────────────────────────
NEO4J_URI=bolt://localhost:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=mirofish

# ── Embeddings (Ollama) ───────────────────────────────────────────────
EMBEDDING_MODEL=nomic-embed-text
EMBEDDING_BASE_URL=http://localhost:11434

# ── Optional: swap Ollama for any OpenAI-compatible provider ─────────
# LLM_API_KEY=$OPENAI_API_KEY
# LLM_BASE_URL=https://api.openai.com/v1
# LLM_MODEL_NAME=gpt-4o

Core Python API

GraphStorage Interface

The abstraction layer between MiroFish and the graph database:

from backend.storage.base import GraphStorage
from backend.storage.neo4j_storage import Neo4jStorage

# Initialize storage (typically done via Flask app.extensions)
storage = Neo4jStorage(
    uri=os.environ["NEO4J_URI"],
    user=os.environ["NEO4J_USER"],
    password=os.environ["NEO4J_PASSWORD"],
    embedding_model=os.environ["EMBEDDING_MODEL"],
    embedding_base_url=os.environ["EMBEDDING_BASE_URL"],
    llm_base_url=os.environ["LLM_BASE_URL"],
    llm_api_key=os.environ["LLM_API_KEY"],
    llm_model=os.environ["LLM_MODEL_NAME"],
)

Building a Knowledge Graph from a Document

from backend.services.graph_builder import GraphBuilder

builder = GraphBuilder(storage=storage)

# Feed a document string
with open("press_release.txt", "r") as f:
    document_text = f.read()

# Extract entities + relationships, store in Neo4j
graph_id = builder.build(
    content=document_text,
    title="Q4 Earnings Report",
    source_type="financial_report",
)

print(f"Graph built: {graph_id}")
# Returns a graph_id used for subsequent simulation runs

Creating and Running a Simulation

from backend.services.simulation import SimulationService

sim = SimulationService(storage=storage)

# Create a simulation environment from an existing graph
sim_id = sim.create_environment(
    graph_id=graph_id,
    agent_count=200,           # Number of agents to generate
    simulation_hours=24,       # Simulated time span
    platform="twitter",        # "twitter" | "reddit" | "weibo"
)

# Run the simulation (blocking — use async wrapper for production)
result = sim.run(sim_id=sim_id)

print(f"Simulation complete. Posts generated: {result['post_count']}")
print(f"Sentiment trajectory: {result['sentiment_over_time']}")

Querying Simulation Results

from backend.services.report import ReportAgent

report_agent = ReportAgent(storage=storage)

# Generate a structured analysis report
report = report_agent.generate(
    sim_id=sim_id,
    focus_group_size=10,    # Number of agents to interview
    include_graph_search=True,
)

print(report["summary"])
print(report["key_narratives"])
print(report["sentiment_shift"])
print(report["influential_agents"])

Chatting with a Simulated Agent

from backend.services.agent_chat import AgentChatService

chat = AgentChatService(storage=storage)

# List agents from a completed simulation
agents = chat.list_agents(sim_id=sim_id, limit=10)
agent_id = agents[0]["id"]

print(f"Chatting with: {agents[0]['persona']['name']}")
print(f"Personality: {agents[0]['persona']['traits']}")

# Send a message — agent responds in-character with full memory
response = chat.send(
    agent_id=agent_id,
    message="Why did you post that criticism about the earnings report?",
)

print(response["reply"])
# → Agent responds using its personality, opinion bias, and post history

Hybrid Search on the Knowledge Graph

from backend.services.search import SearchService

search = SearchService(storage=storage)

# Hybrid search: 0.7 * vector similarity + 0.3 * BM25
results = search.query(
    text="executive compensation controversy",
    graph_id=graph_id,
    top_k=5,
    vector_weight=0.7,
    bm25_weight=0.3,
)

for r in results:
    print(r["entity"], r["relationship"], r["score"])

Implementing a Custom GraphStorage Backend

from backend.storage.base import GraphStorage
from typing import List, Dict, Any

class MyCustomStorage(GraphStorage):
    """
    Swap Neo4j for any graph DB by implementing this interface.
    Register via Flask app.extensions['neo4j_storage'] = MyCustomStorage(...)
    """

    def store_entity(self, entity: Dict[str, Any]) -> str:
        # Store entity, return entity_id
        raise NotImplementedError

    def store_relationship(
        self,
        source_id: str,
        target_id: str,
        relation_type: str,
        properties: Dict[str, Any],
    ) -> str:
        raise NotImplementedError

    def vector_search(
        self, embedding: List[float], top_k: int = 5
    ) -> List[Dict[str, Any]]:
        raise NotImplementedError

    def keyword_search(
        self, query: str, top_k: int = 5
    ) -> List[Dict[str, Any]]:
        raise NotImplementedError

    def get_agent_memory(self, agent_id: str) -> Dict[str, Any]:
        raise NotImplementedError

    def update_agent_memory(
        self, agent_id: str, memory_update: Dict[str, Any]
    ) -> None:
        raise NotImplementedError

Flask App Integration Pattern

# backend/app.py — how storage is wired via dependency injection
from flask import Flask