Platform Development
Reference Manual

# Standard connection
postgres://user:password@ep-xxx.us-east-2.aws.neon.tech/neondb?sslmode=require

# Pooled (for serverless / Vercel — use this in Next.js API routes):
postgres://user:password@ep-xxx-pooler.us-east-2.aws.neon.tech/neondb?sslmode=require

# Pull env vars from Vercel to local dev:
vercel env pull .env.local

from sqlalchemy import create_engine, text
import os

engine = create_engine(os.environ["DATABASE_URL"])

with engine.connect() as conn:
    result = conn.execute(
        text("SELECT * FROM bids WHERE status = :s"),
        {"s": "open"}
    )
    for row in result:
        print(row)

npm i -g vercel
vercel login
cd my-project
vercel          # deploys to preview URL
vercel --prod   # promotes to production

# Environment variables
vercel env add DATABASE_URL
vercel env add ANTHROPIC_API_KEY
vercel env pull .env.local    # pull to local dev

// app/api/bids/route.js
import { neon } from '@neondatabase/serverless';

export async function GET() {
  const sql = neon(process.env.DATABASE_URL);
  const bids = await sql`SELECT * FROM bids WHERE status = 'open'`;
  return Response.json(bids);
}

export async function POST(req) {
  const sql = neon(process.env.DATABASE_URL);
  const { project, amount } = await req.json();
  const result = await sql`
    INSERT INTO bids (project, amount, status)
    VALUES (${project}, ${amount}, 'open')
    RETURNING *`;
  return Response.json(result[0], { status: 201 });
}

# Step 1 — Add in Eagle's domain registrar
CNAME  parts  →  cname.vercel-dns.com

# Step 2 — Add domain in Vercel dashboard
# Project: eagle-parts → Settings → Domains
# Enter: parts.eaglegroup.com
# Vercel provisions SSL automatically

# Step 3 — Add link in WordPress nav menu
# Appearance → Menus → Custom Link
# URL: https://parts.eaglegroup.com  |  Label: Shop Parts

# Optional path-based route (eaglegroup.com/shop)
# Requires Vercel rewrite or Cloudflare proxy rule

# Install Node.js first (nodejs.org), then:
npm install -g @anthropic-ai/claude-code

# Set API key
$env:ANTHROPIC_API_KEY = 'sk-ant-...'

# Persist across sessions — add to PowerShell profile:
notepad $PROFILE
# Add: $env:ANTHROPIC_API_KEY = 'sk-ant-...'

# Run in your project folder
cd C:\Projects\MyApp
claude

# One-shot task (no interaction)
claude "refactor auth.py to use async/await"

# Override token limit
claude --max-tokens 8000

{
  "mcpServers": {
    "neon": {
      "command": "npx",
      "args": ["-y", "@neondatabase/mcp-server-neon"],
      "env": { "NEON_API_KEY": "your-neon-api-key" }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..." }
    }
  }
}

const response = await fetch("https://api.anthropic.com/v1/messages", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "claude-sonnet-4-20250514",
    max_tokens: 1000,
    messages: [{ role: "user", content: "List my open GitHub issues" }],
    mcp_servers: [
      { type: "url", url: "https://mcp.github.com/sse", name: "github-mcp" }
    ]
  })
});

import smtplib, os
from sqlalchemy import create_engine, text
from email.mime.text import MIMEText

engine = create_engine(os.environ["DATABASE_URL"])
with engine.connect() as conn:
    rows = conn.execute(text(
        "SELECT project, amount FROM bids WHERE status='open' ORDER BY amount DESC"
    )).fetchall()

body = "Open Bids Summary\n" + "\n".join(
    f"  {r.project}: ${r.amount:,.2f}" for r in rows
)
msg = MIMEText(body)
msg["Subject"] = f"Open Bids — {len(rows)} active"
msg["From"]    = os.environ["SMTP_FROM"]
msg["To"]      = os.environ["SMTP_TO"]

with smtplib.SMTP_SSL("smtp.gmail.com", 465) as smtp:
    smtp.login(os.environ["SMTP_FROM"], os.environ["SMTP_PASS"])
    smtp.send_message(msg)

// Charge on behalf of MJ Kids Yoga connected account
import Stripe from 'stripe';
const stripe = new Stripe(process.env.STRIPE_PLATFORM_SECRET_KEY);

const paymentIntent = await stripe.paymentIntents.create({
  amount: 999,  // $9.99 in cents
  currency: 'usd',
  application_fee_amount: 0,  // Set non-zero if Salud takes a platform %
  transfer_data: {
    destination: process.env.MJ_YOGA_STRIPE_ACCOUNT_ID,  // acct_xxx
  },
});

# Self-host on Railway or DigitalOcean ($6/mo Droplet)
docker run -it --rm \
  --name n8n \
  -p 5678:5678 \
  -v ~/.n8n:/home/node/.n8n \
  -e N8N_BASIC_AUTH_ACTIVE=true \
  -e ANTHROPIC_API_KEY=sk-ant-... \
  docker.n8n.io/n8nio/n8n

# Open: http://localhost:5678
# Add Claude: Integrations → AI → Anthropic Chat Model

CREATE TABLE animals (
  id          SERIAL PRIMARY KEY,
  name        VARCHAR(100) NOT NULL,
  habitat     VARCHAR(100),
  rarity      VARCHAR(20) CHECK (rarity IN ('common','rare','epic','legendary')),
  created_at  TIMESTAMPTZ DEFAULT NOW()
);

CREATE TABLE yoga_cards (
  id               SERIAL PRIMARY KEY,
  animal_id        INT REFERENCES animals(id),
  pose_name        VARCHAR(150),
  sanskrit_name    VARCHAR(150),
  skill_name       VARCHAR(100),
  skill_bonus      INT,
  weakness_name    VARCHAR(100),
  weakness_penalty INT,
  real_world_fact  TEXT,
  yoga_benefit     TEXT,
  age_range        VARCHAR(20),   -- '4-6', '7-10', '10+'
  difficulty       INT CHECK (difficulty BETWEEN 1 AND 5),
  image_url        TEXT,
  card_art_url     TEXT,
  video_url        TEXT,
  card_number      VARCHAR(10)    -- 'MJ-042'
);

CREATE TABLE flows (
  id          SERIAL PRIMARY KEY,
  user_id     INT REFERENCES users(id),
  title       VARCHAR(200),
  is_public   BOOLEAN DEFAULT FALSE,
  share_code  VARCHAR(12) UNIQUE,
  created_at  TIMESTAMPTZ DEFAULT NOW()
);

CREATE TABLE flow_cards (
  id        SERIAL PRIMARY KEY,
  flow_id   INT REFERENCES flows(id),
  card_id   INT REFERENCES yoga_cards(id),
  position  INT,
  hold_secs INT DEFAULT 30
);

from sqlalchemy import create_engine, Column, Integer, String, Numeric
from sqlalchemy.orm import DeclarativeBase, Session
import os

engine = create_engine(os.environ["DATABASE_URL"])

class Base(DeclarativeBase): pass

class Bid(Base):
    __tablename__ = "bids"
    id      = Column(Integer, primary_key=True)
    project = Column(String(200))
    amount  = Column(Numeric(12, 2))
    status  = Column(String(50), default="open")

Base.metadata.create_all(engine)

# Create
with Session(engine) as s:
    s.add(Bid(project="Eagle Warehouse", amount=142500))
    s.commit()

# Read
with Session(engine) as s:
    open_bids = s.query(Bid).filter_by(status="open").all()

# Update
with Session(engine) as s:
    bid = s.get(Bid, 1)
    bid.status = "awarded"
    s.commit()

// app/api/analyze/route.js
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic(); // uses ANTHROPIC_API_KEY env

export async function POST(req) {
  const { text } = await req.json();
  const msg = await client.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1024,
    messages: [{ role: 'user', content: `Analyze this: ${text}` }]
  });
  return Response.json({ result: msg.content[0].text });
}