llmggfu — Autonomous Product Foundry

Transform incomplete ideas into production-ready applications — autonomously.

llmggfu implements a 25-step pipeline that takes a problem statement and produces a launched product, complete with research, compliance review, marketing materials, and performance tracking.

Architecture

┌─────────────────────────────────────────────────────────────┐
│                    Foundry (main)                           │
├─────────────────────────────────────────────────────────────┤
│  SDK · ADK · MCP Server · REST API · Hooks · Plugins       │
├─────────────────────────────────────────────────────────────┤
│  Research    Prompt     Ambient    User      Identity      │
│  Engine      Genome     Intent     Account   Wallet        │
│  Credential  Registra-  Opportu-  Product   Compliance     │
│  Store       tion       nity      Generator  Engine        │
│  Marketing   Witness    Evolution  Pipeline                 │
│  System      Network    Engine     Orchestrator             │
├─────────────────────────────────────────────────────────────┤
│  Crypto (AES-256-GCM) · Logger · DB (JSON / SQLite)       │
├─────────────────────────────────────────────────────────────┤
│  LLM: OpenAI · Anthropic · Gemini · Mock                   │
└─────────────────────────────────────────────────────────────┘

Installation

pip install llmggfu

# With REST API
pip install "llmggfu[api]"

# With LLM providers
pip install "llmggfu[llm]"

# Everything
pip install "llmggfu[all]"

# Development
pip install "llmggfu[dev]"

Quick Start

from llmggfu.sdk import FoundrySDK

sdk = FoundrySDK()

result = (
    sdk.create_opportunity(
        problem="Developers need API monitoring",
        target_user="Indie developers",
        market_need="Affordable monitoring",
        competitive_gap="No affordable option",
        proposed_product="API Monitor",
        technical_approach="FastAPI + SQLite",
        estimated_complexity="low",
        distribution_plan="Product Hunt",
        monetization_model="Freemium $9/mo",
        risk_assessment="Low",
        prototype_path="FastAPI",
        launch_path="PH + HN",
    )
    .generate_variants(tech_stack=["Python", "FastAPI"])
    .select_recommended()
    .run_pipeline()
    .result()
)

print(f"Status: {result['status']}")
print(f"Project: {result['project'].name}")

SDK — High-Level API

# Users
user = sdk.create_user(name="Alice", email="alice@example.com")

# Opportunities
opps = sdk.list_opportunities(status="prepared")
ranked = sdk.rank_opportunities(limit=5)

# Pipeline
run = sdk.start_pipeline("opp_abc123")
run = sdk.run_pipeline(run.id)
sdk.pause_pipeline(run.id)
sdk.resume_pipeline(run.id)

# Projects
projects = sdk.list_projects(status="launched")
sdk.launch_project("proj_xyz")

# Compliance
review = sdk.review_compliance("proj_xyz")

# Research
prior_art = sdk.assess_prior_art("API monitoring")

# Prompt Genome
entry = sdk.create_prompt("Research", "Market research", "internal", "Research {{topic}}")
ranked = sdk.rank_prompts(metric="reliability")

# Identity & Credentials
sdk.init_wallet("user_123")
sdk.add_identity("user_123", "contact", "email", {"value": "alice@example.com"})
sdk.store_credential("stripe", "api_key", "sk_test_...", "secret")

# Witnesses & Metrics
sdk.register_witness("proj_xyz", "Bob", "bob@example.com", "v0.1.0")
sdk.record_metrics("proj_xyz", activation=0.3, retention=0.8, revenue=1200)

ADK — Agent Development Kit

from llmggfu.adk import AgentSwarm, ResearchAgent, OpportunityAgent, PipelineAgent, ComplianceAgent

swarm = AgentSwarm(sdk)
swarm.add(ResearchAgent(sdk))
swarm.add(OpportunityAgent(sdk))
swarm.add(PipelineAgent(sdk))
swarm.add(ComplianceAgent(sdk))

results = swarm.run_pipeline_flow("API monitoring", target_user="Indie devs", ...)

# Custom agent
from llmggfu.adk import Agent, AgentRole

class MyAgent(Agent):
    role = AgentRole.CUSTOM
    def _execute_impl(self, task, **ctx):
        return f"Handled: {task}"

MCP Server

llmggfu-mcp          # CLI
python -m llmggfu.mcp_server  # Python

15 tools: list_opportunities, create_opportunity, start_pipeline, run_pipeline, review_compliance, assess_prior_art, create_prompt, launch_project, register_witness, record_metrics, analyze_performance, etc.

REST API

pip install "llmggfu[api]"
llmggfu-api --port 8000

Endpoints: GET/POST /api/opportunities, POST /api/pipeline/start, POST /api/pipeline/run, GET /api/projects, POST /api/compliance/review, GET /api/research/{topic}, etc.

Hooks — Event System

from llmggfu.hooks import HookSystem, HookEvent

hooks = HookSystem()

@hooks.on(HookEvent.PIPELINE_COMPLETED, webhook="https://example.com/hook")
def on_complete(run_id, **ctx):
    print(f"Pipeline {run_id} done!")

20 events: pipeline.started/completed/failed/paused/resumed, step.completed/failed, opportunity.created/selected, project.launched, compliance.reviewed, witness.registered, metrics.recorded, etc.

LLM Providers

from llmggfu.llm import LLMManager, OpenAIProvider, AnthropicProvider, GeminiProvider

manager = LLMManager.from_config(sdk.foundry.config)
response = manager.complete("Research API monitoring", system="You are a research assistant.")

Supports OpenAI, Anthropic, Gemini, and Mock providers. Auto-detected from config.

Plugins

from llmggfu.plugins import PluginManager

plugins = PluginManager(sdk)

@plugins.step("custom_analysis")
def custom_step(run, opp):
    return "Custom analysis complete"

@plugins.hook(HookEvent.PIPELINE_COMPLETED)
def on_complete(run_id, **ctx):
    send_notification(run_id)

Configuration

# foundry.yaml
db:
  path: ./data/foundry.db
  backend: sqlite          # sqlite or json
llm:
  provider: openai
  api_key: ${LLM_API_KEY}
  model: gpt-4o-mini
wallet:
  encryption_key: ${WALLET_ENCRYPTION_KEY}
log:
  level: info

from llmggfu.config import load_config
config = load_config("foundry.yaml")
sdk = FoundrySDK(config)

Environment variables: FOUNDRY_DB_PATH, FOUNDRY_DB_BACKEND, FOUNDRY_LLM_PROVIDER, FOUNDRY_LLM_API_KEY, FOUNDRY_LLM_MODEL, FOUNDRY_WALLET_ENCRYPTION_KEY, FOUNDRY_LOG_LEVEL.

Storage Backends

# JSON files (default)
from llmggfu.db import FoundryDB
db = FoundryDB("./data/foundry.db")

# SQLite
from llmggfu.sqlite_db import SQLiteDB
db = SQLiteDB("./data/foundry.db")

# In-memory
db = FoundryDB(":memory:")
db = SQLiteDB(":memory:")

Async Pipeline

import asyncio
run = sdk.start_pipeline("opp_abc123")
result = asyncio.run(sdk.run_pipeline_async(run.id))

Docker

docker build -t llmggfu .
docker run -p 8000:8000 llmggfu

Web Dashboard

llmggfu-dashboard --port 3000

Real-time pipeline visualization.

25-Step Pipeline

Security

• AES-256-GCM encryption for sensitive data at rest
• PBKDF2 key derivation (100k iterations)
• Granular sharing with field-level permission scopes
• Audit logging for every read, write, share, revoke
• Sensitive data filtering — emails, phones, cards, SSNs redacted
• Human verification — pauses for CAPTCHA, biometrics, legal terms

Tests

pip install "llmggfu[test]"
python -m pytest -v

Subsystems

License

MIT