AIForge Starter Pack

The #1 AI-native monorepo template for 2026+

Ship web, mobile, and AI products at maximum velocity with 90%+ code sharing.

Getting Started · AI Quick-Start · Why AIForge · Deploy · Contributing · Psypher AI

Love this project? Give it a :star: to help others discover it!

What is AIForge?

AIForge is the canonical monorepo blueprint for every AI product you build in 2026 and beyond. One pnpm dev command spins up a Next.js web app, an Expo mobile app, and a FastAPI + LangGraph backend — all sharing 90%+ of their code.

# Scaffold → Install → Run (under 2 minutes)
npx degit psypherai/AIForge my-app && cd my-app
pnpm install && cp .env.example .env
pnpm dev

Web on localhost:3000 · Mobile on localhost:8081 · API on localhost:8000 · Docs on localhost:8000/docs

Why AIForge?

Tech Stack (February 2026 — Best-of-the-Best)

Architecture

.
├── apps/
│   ├── web/                 # Next.js 16 + Turbopack + shadcn/ui + PWA
│   ├── mobile/              # Expo SDK 54 + Solito + NativeWind
│   └── backend/             # Python FastAPI + LangGraph + uv
│
├── packages/
│   ├── ui/                  # Shared UI (shadcn + Tailwind RN primitives)
│   ├── core/                # Types, Zod schemas, utils, constants
│   ├── ai/                  # Prompt factory, tools, RAG, multi-agent, realtime
│   ├── mcp/                 # MCP server + client (Model Context Protocol)
│   ├── api-client/          # Generated OpenAPI client + React Query hooks
│   ├── config/              # Shared Tailwind, TypeScript configs
│   ├── observability/       # Langfuse + LangSmith wrappers
│   ├── db/                  # Supabase types + pgvector helpers
│   ├── evals/               # Agent evaluation suite
│   ├── create-aiforge/      # CLI scaffolding tool (npx create-aiforge)
│   └── eslint-config/       # ESLint flat config (fallback)
│
├── supabase/
│   └── functions/           # Edge Functions (ai-chat, embed, webhook)
│
├── docs/                    # Upgrade guides and documentation
├── turbo.json               # Turborepo config (incl. Python tasks)
├── docker-compose.yml       # Local Supabase + Langfuse + Backend
└── .github/workflows/       # CI: TS + Python + E2E + Docker

Getting Started

Prerequisites

Quick Start

# 1. Scaffold and install
npx degit psypherai/AIForge my-app
cd my-app
pnpm install

# 2. Set up Python backend
cd apps/backend && uv sync && cd ../..

# 3. Configure environment
cp .env.example .env
# Edit .env with your API keys (OPENAI_API_KEY, SUPABASE_URL, etc.)

# 4. Start local services (optional — for Supabase + Langfuse)
docker compose up -d

# 5. Run everything concurrently
pnpm dev

That's it. Three apps running simultaneously:

Commands

pnpm dev              # Start all (web + mobile + backend)
pnpm dev:web          # Next.js only
pnpm dev:mobile       # Expo only
pnpm dev:backend      # FastAPI only
pnpm build            # Build all packages
pnpm test             # Run all tests (Vitest)
pnpm typecheck        # TypeScript check
pnpm check            # Biome lint + format
pnpm api:generate     # Regenerate API client from OpenAPI spec

AI Quick-Start Guide

1. Streaming Chat (Web)

The /chat page is pre-built with Vercel AI SDK:

// apps/web/app/api/chat/route.ts — already set up!
import { openai } from '@ai-sdk/openai';
import { streamText } from 'ai';
import { SYSTEM_PROMPTS } from '@aiforge/ai/prompts';

export async function POST(req: Request) {
  const { messages } = await req.json();
  const result = streamText({
    model: openai('gpt-4o'),
    system: SYSTEM_PROMPTS.assistant,
    messages,
  });
  return result.toDataStreamResponse();
}

2. Universal AI Hook (Web + Mobile)

import { useAI } from '@aiforge/ai/use-ai';

function ChatScreen() {
  const { messages, send, isLoading } = useAI({
    model: 'gpt-4o',
    systemPrompt: 'You are a helpful assistant.',
  });

  return (
    <View className="flex-1 p-4">
      {messages.map(m => <Text key={m.id}>{m.content}</Text>)}
      <Button onPress={() => send('Hello!')} disabled={isLoading}>Send</Button>
    </View>
  );
}

3. Structured Outputs

import { openai } from '@ai-sdk/openai';
import { generateObject } from 'ai';
import { extractionSchema } from '@aiforge/ai/schemas';

const { object } = await generateObject({
  model: openai('gpt-4o'),
  schema: extractionSchema,
  prompt: 'Extract entities: "Tim Cook announced iPhone 17 in Cupertino"',
});
// object.entities → [{ text: 'Tim Cook', type: 'person' }, ...]

4. Tool Calling

import { createToolSet } from '@aiforge/ai/tools';
import { generateText } from 'ai';

const { text } = await generateText({
  model: openai('gpt-4o'),
  tools: createToolSet(['search', 'calculator', 'datetime']),
  prompt: 'What time is it in Tokyo?',
  maxSteps: 5,
});

5. RAG with pgvector

import { searchSimilar, upsertDocuments } from '@aiforge/ai/rag-helpers';

// Index documents
await upsertDocuments(supabase, [
  { content: 'AIForge is the best monorepo.', metadata: { source: 'docs' } },
]);

// Semantic search
const results = await searchSimilar(supabase, 'best monorepo', { topK: 5 });

6. LangGraph Agent (Python)

curl -X POST http://localhost:8000/api/v1/chat \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role": "user", "content": "Hello!"}]}'

7. Agent Evaluations

import { runEval, scorers, EXAMPLE_DATASET } from '@aiforge/evals';

const results = await runEval({
  dataset: EXAMPLE_DATASET,
  agent: myAgent,
  scorers: [scorers.relevance, scorers.coherence, scorers.safety],
});
console.log(`Average score: ${results.summary.averageScore}`);

Deployment

Web (Vercel)

vercel --cwd apps/web

Mobile (Expo EAS)

cd apps/mobile && eas build --platform all && eas submit --platform all

Backend (Fly.io / Render / Railway)

cd apps/backend && fly launch && fly deploy

Full Stack (Docker Compose)

docker compose up -d

Roadmap

• Monorepo with Turborepo + pnpm
• Next.js 16 web app with shadcn/ui
• Expo mobile app with NativeWind
• FastAPI + LangGraph backend
• Supabase pgvector RAG
• Langfuse observability
• Agent evaluation suite
• Docker Compose for local dev
• GitHub Actions CI
• MCP (Model Context Protocol) server + client
• Multi-agent orchestration (Supervisor, Pipeline, Parallel, Debate)
• Supabase Edge Functions (ai-chat, embed, webhook)
• Real-time collaborative AI (Supabase Realtime)
• PWA support (installable web app + offline)
• Quick scaffold via npx degit psypherai/AIForge
• Expo SDK 55 + NativeWind v5 upgrade guide
• Scalar API Reference (replaced Swagger UI)

Coming Next

High Priority — Differentiators

• A2A Protocol (Google Agent-to-Agent) — agent-to-agent communication alongside MCP
• Voice AI — useVoiceChat hook with OpenAI Realtime API / Deepgram STT+TTS
• AI Guardrails — content filtering, PII detection, prompt injection protection
• Human-in-the-Loop — AI actions requiring user approval before execution
• AI Payments (x402) — agents that can pay for tools and services

Medium Priority — Production Essentials

• AI Background Agents — long-running async tasks with notifications
• CLI scaffolding tool (npx create-aiforge) — interactive project setup
• Multi-provider LLM Router — auto-route between OpenAI / Anthropic / Gemini / local models
• Fine-tuning Pipeline — scripts to fine-tune on your app's data
• Prompt Playground — built-in UI to test and iterate prompts
• E2E AI Testing — automated LLM output validation beyond unit tests

Ecosystem Integrations

• Cloudflare Workers AI — alternative edge deployment
• Expo Push Notifications + AI — push triggered by AI agents
• Stripe Integration — SaaS billing with AI usage metering
• Admin Dashboard — analytics for AI usage, costs, latency

Contributing

We love contributions! Check out our Contributing Guide for details on how to get started.

Whether it's a bug fix, new feature, documentation improvement, or even a typo fix — every contribution is valued.

Community

• GitHub Discussions — Ask questions, share ideas
• GitHub Issues — Report bugs, request features
• Star the repo to stay updated with releases

Star History

License

MIT — Psypher AI 2026

Built with purpose by Psypher AI

If AIForge helped you ship faster, consider giving it a :star:

Report Bug · Request Feature