IdeaForge - GitLite

KO | EN

gitlite — search

#javascript #python #hacktoberfest #llm #go #android #deep-learning #docker #awesome #kubernetes #vue #pytorch #mcp #openai

IdeaForge

(★ 52)

No description available.

File Explorer

Download Latest Version (.zip)

- - __init__.py
  - config.py
  - main.py
- .env.example
- Dockerfile
- requirements.txt
- seed_mechanisms.json
- ARCHITECTURE.md
- - App.vue
  - env.d.ts
  - main.ts
  - style.css
- Dockerfile
- index.html
- package-lock.json
- package.json
- tsconfig.json
- vite.config.ts
.gitignore
docker-compose.yml
package-lock.json
package.json
README.md

# Installation Guide

1. Get the code

git clone https://github.com/776306542/IdeaForge

Downloads the entire project code from GitHub to your computer.

cd IdeaForge

Moves into the project folder you just downloaded.

2. Docker

Easy Recommended

Prerequisites

Git Needed to download the project code from GitHub.
Docker Desktop Needed to build and run containers. Install it and keep it running in the background.

docker compose up --build

Builds and starts all defined containers (server, database, etc.) at once, in the background.

✅ Run docker compose ps to check the containers are Up. If the README mentions a port, open http://localhost:PORT in your browser.

Pulled directly from this repo's README.

3. Node.js

Easy

Prerequisites

Git Needed to download the project code from GitHub.
Node.js Node.js must be installed to use npm. The LTS version is recommended.

npm install

Downloads and installs the libraries listed in package.json.

npm run dev

Starts the development/run server.

✅ After running the command, open the address shown in the terminal (usually something like http://localhost:3000) in your browser.

Pulled directly from this repo's README.

4. Python

Easy

Prerequisites

Git Needed to download the project code from GitHub.
Python 3 On Windows, be sure to check 'Add Python to PATH' during installation.

pip install -r requirements.txt

Installs the Python libraries listed in requirements.txt (or similar).

✅ If it runs without errors and prints output in the terminal, it worked.

Pulled directly from this repo's README.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# IdeaForge

**IdeaForge is not a chatbot. It is not a RAG app. It is not a prompt wrapper.**

IdeaForge is an experimental AI innovation engine that tries to generate new hypotheses by forcing distant domains to collide at the level of mechanisms.

Instead of asking, "What does the model know about this topic?", IdeaForge asks:

> What is the underlying problem pattern, which far-away domains have solved structurally similar problems, and what new mechanism emerges if we fuse and mutate their solution strategies?

The goal is not to answer questions.

The goal is to manufacture better questions, stranger mechanisms, and higher-quality innovation hypotheses.

## Core Formula

```text
Innovation =
Problem Essence
× Random Domain Jump
× Mechanism Transfer
× Mechanism Fusion
× Mechanism Mutation
× Evolution Selection
```

Short name:

```text
PE-RDJ-MT-MF-MM-ES
```

## Why IdeaForge Exists

Most LLM creativity today is powered by:

```text
knowledge retrieval + knowledge recombination + probabilistic generation
```

IdeaForge explores another path:

```text
problem abstraction
+ distant random domain jumps
+ mechanism extraction
+ mechanism fusion
+ mechanism mutation
+ critic-driven evolution
```

The key design choice is counterintuitive:

**Do not search for the most similar domain.**

Search for domains that are far enough away, but have solved a similar underlying mechanism problem.

For example, for:

```json
{
  "domain": "Medicine",
  "problem": "early cancer screening"
}
```

IdeaForge does not begin with medical literature. It first abstracts the problem into:

```text
weak anomaly detection in a high-noise environment
```

Then it may jump to domains such as:

- radar
- ant colonies
- port logistics
- astronomy
- cybersecurity
- ecology

The innovation comes from the collision.

## What IdeaForge Does

IdeaForge runs a seven-stage innovation workflow:

1. **Problem Essence Extraction**
   Strip away the surface domain and extract objects, goals, constraints, conflicts, and failure modes.

2. **Random Distant Domain Jump**
   Select domains with high domain distance and medium mechanism similarity.

3. **Mechanism Transfer**
   Pull mechanism genomes from the Mechanism Genome Library.

4. **Mechanism Alchemy**
   Fuse and mutate mechanisms through combination, conflict resolution, inversion, amplification, recursion, and nesting.

5. **Innovation Hypothesis Generation**
   Map the new mechanism back to the target problem.

6. **Critic Society**
   Independent critic agents evaluate scientific plausibility, engineering feasibility, risks, novelty, and long-term potential.

7. **Evolution Selection**
   Keep the top ideas, mutate them again, and evolve across generations.

## System Architecture

```text
Vue 3 UI
  |
  | REST
  v
FastAPI Backend
  |
  v
IdeaForge Workflow Engine
  |
  +--> Problem Essence Extractor
  +--> Random Domain Jumper
  +--> Mechanism Genome Library
  +--> Mechanism Alchemist
  +--> Hypothesis Generator
  +--> Critic Society
  +--> Evolution Selector
  |
  +--> PostgreSQL schema
  +--> Neo4j mechanism graph interface
  +--> LLM provider abstraction
```

## Mechanism Genome Library

IdeaForge stores mechanisms, not documents.

A mechanism genome looks like this:

```json
{
  "id": "radar_1",
  "name": "Weak Signal Accumulation",
  "domain": "Radar",
  "problem_solved": "Detecting weak distant targets in strong background noise",
  "mechanism_steps": [
    "model background noise",
    "accumulate multi-frame signals",
    "enhance trajectory consistency",
    "apply adaptive thresholding"
  ],
  "mechanism_tags": ["weak_signal", "noise_modeling", "temporal_accumulation"],
  "conflict_tags": ["centralized", "deterministic"],
  "transferability_score": 0.92
}
```

The seed library currently includes mechanisms from radar, ant colonies, port logistics, ecology, astronomy, cybersecurity, finance, games, material science, and social propagation.

## Critic Society

Every generated hypothesis is reviewed by five independent critic roles:

- **Scientist**: scientific plausibility
- **Engineer**: implementation feasibility
- **Skeptic**: hidden assumptions and failure modes
- **Competitor**: novelty and differentiation
- **Futurist**: long-term potential

Their weighted scores drive evolution selection.

## Tech Stack

- **Backend**: FastAPI, Pydantic, SQLAlchemy, LangGraph-compatible workflow structure
- **Frontend**: Vue 3, Vite, TypeScript
- **Data**: PostgreSQL schema, Neo4j mechanism graph interface, JSON mechanism seed library
- **LLM**: OpenAI-compatible API abstraction
- **DevOps**: Docker Compose, root npm scripts

## Quick Start

### 1. Clone

```bash
git clone https://github.com/776306542/IdeaForge.git
cd IdeaForge
```

### 2. Configure the model API

Create `backend/.env`:

```env
LLM_PROVIDER=openai
LLM_MODEL=your-model-name
OPENAI_API_KEY=your-api-key
OPENAI_BASE_URL=https://api.openai.com/v1

DATABASE_URL=postgresql+asyncpg://ideaforge:ideaforge@localhost:5432/ideaforge
NEO4J_URI=bolt://localhost:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=ideaforge123
NEO4J_ENABLED=true
MAX_GENERATIONS=3
TOP_K_IDEAS=3
```

IdeaForge intentionally has **no mock LLM fallback**.

If the model API is not configured or cannot be reached, the forge workflow will not run.

### 3. Install dependencies

Frontend/root dependencies:

```bash
npm install
cd frontend
npm install
cd ..
```

Backend dependencies:

```bash
cd backend
pip install -r requirements.txt
cd ..
```

### 4. Run locally

```bash
npm run dev
```

This starts:

- FastAPI backend at `http://localhost:8000`
- Vue frontend at `http://localhost:5173`

### 5. Test the model API

Open the frontend and click:

```text
Test Model API
```

Or call directly:

```bash
curl http://localhost:8000/forge/llm/test
```

## Docker Compose

```bash
docker compose up --build
```

Services:

- `postgres`
- `neo4j`
- `backend`
- `frontend`

## Main API Endpoints

```text
GET  /health
GET  /forge/llm/test
GET  /forge/domains
GET  /forge/mechanisms
POST /forge/run
POST /forge/run-sync
GET  /forge/runs
GET  /forge/runs/{run_id}
```

Example:

```bash
curl -X POST http://localhost:8000/forge/run-sync \
  -H "Content-Type: application/json" \
  -d '{
    "domain": "Medicine",
    "problem": "early cancer screening",
    "max_generations": 3,
    "top_k": 3,
    "language": "en"
  }'
```

## What This Is Not

IdeaForge is deliberately not:

- a chatbot
- a RAG system
- a search engine
- a paper summarizer
- a prompt engineering template
- a generic autonomous agent

It is a mechanism-level innovation engine.

## Roadmap

- Domain embedding space visualization
- User-editable mechanism genome library
- Mechanism graph exploration in Neo4j
- Streaming forge progress
- Multi-user hypothesis review
- Experiment tracking for hypothesis validation
- GNN-assisted distant domain jump recommendations

## Philosophy

Creativity is often treated as better recombination of nearby concepts.

IdeaForge is built around a different bet:

> The most interesting hypotheses often come from distant systems that solved the same hidden problem under radically different constraints.

IdeaForge is a small attempt to turn that bet into software.