Getting Started

This guide teaches you how to install and configure the WDG AI Development Environment from scratch. We'll explain every step and every concept as we go.

What You're Installing

The WDG AI Development Environment is a local WordPress development platform that includes:

Multiple WordPress Sites: Run unlimited WordPress projects simultaneously
AI Code Search: Semantic search across your codebase using local AI models
Wikit Framework: WDG's enterprise WordPress framework with 50+ Gutenberg blocks
Development Tools: Database management, code indexing, and project templates

Key Concept - Local AI: This platform uses AI models that run entirely on your computer. No API keys required, no cloud services, complete privacy.

Prerequisites

Required Software

Before installing, you need these tools on your computer:

1. Docker Desktop (Recommended) or Docker Engine

Minimum Version: 20.10 or higher
What it does: Runs isolated containers for WordPress, MySQL, and other services
Download: https://www.docker.com/products/docker-desktop

For macOS/Windows: Install Docker Desktop (includes Docker Compose) For Linux: Install Docker Engine + Docker Compose separately

Check Your Docker Version

bash

docker --version          # Should show 20.10 or higher
docker compose version    # Should show 2.0 or higher

2. Git

What it does: Manages code repositories and enables automatic indexing
Check if installed: git --version
Download: https://git-scm.com/downloads

3. Disk Space

Minimum: 10GB for initial installation
Recommended: 20GB+ (each project needs ~500MB-2GB depending on content)
What uses space: Docker images (3GB), AI models (500MB), WordPress installations

System Requirements

Component	Minimum	Recommended
RAM	8GB	16GB+
CPU	2 cores	4+ cores
OS	macOS 10.15+, Windows 10+, Linux (Ubuntu 20.04+)	Latest versions

Operating System Notes

macOS: Fully supported. Docker Desktop provides best experience.

Linux: Fully supported. You'll install Docker Engine separately. Commands shown use bash/zsh.

Windows: Requires WSL2 (Windows Subsystem for Linux). The platform needs a Linux environment for bash scripts, POSIX file permissions, and Linux containers. See Windows WSL2 Setup below.

Windows WSL2 Setup

If you're on Windows, complete these steps first before proceeding to Installation.

Why WSL2?

This platform requires a Linux environment because:

The wdg CLI tool is a bash script
File operations use POSIX permissions and symbolic links
Docker containers run Linux
Build scripts expect a Unix-like environment

WSL2 provides a full Linux kernel running inside Windows, giving you the best of both worlds.

Installing WSL2

Step 1: Install WSL2

Open PowerShell as Administrator and run:

powershell

wsl --install

This installs WSL2 and Ubuntu automatically.

Step 2: Restart Your Computer

A restart is required for WSL2 to complete installation.

Step 3: Set Up Ubuntu

After restart, open "Ubuntu" from the Start Menu. On first launch:

Choose a username (lowercase, no spaces)
Choose a password (you won't see it as you type)
Wait for setup to complete

Step 4: Update Linux Packages

In your Ubuntu terminal:

bash

sudo apt update && sudo apt upgrade -y

Step 5: Install Docker Desktop for Windows

Download from: https://www.docker.com/products/docker-desktop
Install Docker Desktop
Open Docker Desktop Settings
Go to Resources → WSL Integration
Enable integration with your Ubuntu distribution
Click "Apply & Restart"

Step 6: Verify Docker Works in WSL2

In your Ubuntu terminal:

bash

docker --version
docker compose version

Both should display version numbers.

Accessing Windows Files from WSL2

Your Windows drives are mounted at /mnt/c, /mnt/d, etc.

Windows: C:\Users\YourName\Documents
WSL2: /mnt/c/Users/YourName/Documents

We recommend working in your WSL2 home directory (~/) for better performance.

You're ready! Proceed to Installation below, running all commands in your Ubuntu terminal.

Installation

Step 1: Clone the Repository

Open your terminal and run:

bash

git clone https://github.com/wdgdc/WDG-AI-Development-Environment.git
cd WDG-AI-Development-Environment

What this does: Downloads the platform code to a folder named WDG-AI-Development-Environment and enters that directory.

Windows Users

Make sure you've installed WSL2 first (see Windows WSL2 Setup below). Run all commands in your WSL2 terminal (Ubuntu).

Step 2: Run the Installer

The installer automates the entire setup process.

On macOS/Linux/WSL2:

bash

./install.sh

What the Installer Does

The installation process takes 10-15 minutes and performs these steps:

Creates Docker Network (wdg-network): Allows all services to communicate
Clones Wikit Repositories: Downloads WDG's enterprise WordPress framework
- wikit-core: Core framework plugin
- wikit-theme: Base theme with 50+ blocks
- wikit-facets: Advanced search functionality
- wikit-app: Application framework
Creates Configuration: Copies .env.example to .env with default settings
Builds Docker Images: Creates containers for WordPress, MySQL, Nginx, etc. (~5 min)
Downloads AI Model: Gets the embedding model for semantic search (~2-3 min)
Indexes Framework Code: Creates searchable database of Wikit code (~5-7 min)
Starts Core Services: Launches all Docker containers

Installation Time Factors

Internet Speed: Downloading Docker images and AI models
System Performance: Building images and indexing code
First Time: 10-15 minutes. Subsequent starts are ~30 seconds.

Step 3: Set Up the `wdg` Command

At the end of installation, you'll be prompted to set up the wdg command. You have two options:

Option 1: Shell Alias (Recommended)

bash

# Adds to your ~/.bashrc or ~/.zshrc:
alias wdg='/full/path/to/WDG-AI-Development-Environment/cli/wdg'

✅ No sudo required
✅ Easy to update
✅ Per-user configuration
❌ Requires new terminal session to take effect

Option 2: System Symlink

bash

# Creates symlink in /usr/local/bin/
sudo ln -s /full/path/to/WDG-AI-Development-Environment/cli/wdg /usr/local/bin/wdg

✅ Available immediately
✅ Works for all users
❌ Requires sudo access

We recommend Option 1 (alias). After choosing, either:

Open a new terminal window, OR
Run: source ~/.bashrc (or source ~/.zshrc on macOS)

For This Guide

From this point forward, we'll use just wdg in all commands. If you chose not to set up the command, use wdg instead wherever you see wdg.

Step 4: Verify Installation

Check that all core services are running:

bash

wdg status

You should see output similar to:

Core Services Status:
✓ Nginx (Reverse Proxy): Running on :8880 (HTTP) and :8443 (HTTPS)
✓ MySQL (Database): Running on :3307
✓ Qdrant (Vector Database): Running on :6333
✓ MCP Server (AI Integration): Running on :8765
✓ Indexer (Code Indexing): Running on :8666
✓ Dashboard (Web UI): Running on :3000

What each service does:

Service	Purpose	Access
Nginx	Routes requests to projects via subdomain	Internal
MySQL	Stores WordPress data for all projects	:3307
Qdrant	Vector database for AI semantic search	http://localhost:6333/dashboard
MCP Server	Provides AI tools for Claude Desktop	http://localhost:8765
Indexer	Processes code into searchable vectors	:8666
Dashboard	Web interface for project management	http://localhost:3000

Access the Dashboard

Open http://localhost:3000 in your browser to see a visual overview of all services and projects.

Understanding Key Concepts

Before creating your first project, let's clarify some important concepts.

Subdomain Routing

Each WordPress project gets its own subdomain URL:

https://my-site.localhost:8443 → First project
https://client-project.localhost:8443 → Second project
https://staging.localhost:8443 → Third project

How it works: Nginx (reverse proxy) reads the subdomain and routes to the correct WordPress container.

Why .localhost?: Modern browsers automatically resolve *.localhost to 127.0.0.1 (your computer). No hosts file editing needed.

Why port :8443?: Standard HTTPS port (443) may be in use. We use 8443 to avoid conflicts.

SSL Certificates

Each project gets a self-signed SSL certificate for HTTPS.

What you'll see: Browser warning "Not Secure" or "Certificate Invalid"

Why: Self-signed certificates aren't verified by a certificate authority

Is it safe?: Yes, for local development. The encryption still works, but browsers warn because they can't verify the certificate's authenticity.

To remove the warning: Click "Advanced" → "Proceed to site" in your browser. Or install the certificate in your system's trust store (advanced).

Repository Structure

The platform uses a specific directory structure:

WDG-AI-Development-Environment/
├── projects/                    # Your WordPress sites
│   └── my-site/
│       ├── repositories/        # Project-specific code
│       │   └── my-site/         # Git repository
│       │       └── wp-content/  # WordPress content (themes/plugins)
│       └── config/              # WordPress configuration
│
└── repositories/                # Shared framework code
    ├── wikit-core/              # Available to all projects
    ├── wikit-theme/
    ├── wikit-facets/
    └── wikit-app/

Why the nested structure?

projects/my-site/ = Project container (WordPress, database, settings)
projects/my-site/repositories/ = Where git repos live for this project
projects/my-site/repositories/my-site/ = The actual git repository
projects/my-site/repositories/my-site/wp-content/ = WordPress themes/plugins

This allows:

Each project has its own git history
Projects are completely isolated
You can have different repos for different projects
Easy to backup/clone/share just the project's code

Wikit Framework

Wikit is WDG's enterprise WordPress framework included with this platform:

wikit-core: Custom post types, taxonomies, core functionality
wikit-theme: Base theme with 50+ Gutenberg blocks
wikit-facets: Advanced search and filtering
wikit-app: Application framework for complex sites

These are installed in the central repositories/ folder and available to all projects.

Vector Database & Semantic Search

What is it?: The platform indexes your code into a "vector database" (Qdrant) that enables AI-powered semantic search.

How it works:

Your code is processed through an AI model (runs locally)
The model converts code into mathematical vectors (lists of numbers)
Vectors are stored in Qdrant database
When you search, your query becomes a vector
Qdrant finds code with similar vectors (similar meaning)

Why it's useful: Find code by what it DOES, not just what it's called.

Example:

Search: "user authentication" → Finds login functions even if they don't mention "authentication"
Search: "display product prices" → Finds price display code across your entire codebase

MCP (Model Context Protocol)

MCP is a protocol that lets Claude Desktop (and other AI assistants) search your code.

In simple terms: It's a bridge between AI chat apps and your codebase.

You get: Ask Claude "Find all WordPress hooks in my theme" and it searches your actual code.

Creating Your First Project

Now let's create a WordPress site. You have two options:

Option 1: Basic WordPress Site

Creates a minimal WordPress installation with Wikit framework available.

bash

wdg create my-first-site

What this creates:

WordPress 6.x installation
MySQL database: my_first_site
Admin user: admin / admin
Access URL: https://my-first-site.localhost:8443
Empty wp-content/ directory
Wikit framework available but not activated

Best for: Importing existing client sites, starting from scratch your way, testing WordPress plugins.

Option 2: Full Wikit Setup (Recommended for New Projects)

Creates WordPress with a complete Wikit repository structure, git initialization, and optional template content.

bash

wdg create my-first-site --init-wikit

What this creates: Everything from Option 1, PLUS:

Git repository initialized in projects/my-first-site/repositories/my-first-site/
Custom theme: my-first-site-theme (inherits from Wikit)
Custom plugin: my-first-site-app (extends Wikit functionality)
Git hooks installed (auto-indexes code on commit)
Code automatically indexed for AI search
.gitignore, .editorconfig, Claude/Cursor AI configs

Best for: New projects using WDG's Wikit framework, learning Wikit blocks, starting with examples.

Comparison Table

Feature	Basic (`wdg create`)	Full Wikit (`wdg create --init-wikit`)
WordPress Installed	✅	✅
Database Created	✅	✅
Wikit Available	✅	✅
Git Repository	❌	✅
Custom Theme	❌	✅ my-first-site-theme
Custom Plugin	❌	✅ my-first-site-app
AI Search Indexed	❌ Manual	✅ Automatic
Git Hooks	❌	✅
AI Assistant Configs	❌	✅ Claude, Cursor, Gemini

Choosing an Option

New WDG project? Use --init-wikit
Existing client site? Use basic, then import their code
Learning Wikit? Use --init-wikit
Custom from scratch? Use basic

Creating the Project

Let's create a full Wikit project:

bash

wdg create my-first-site --init-wikit

You'll see:

Creating WordPress project: my-first-site
✓ Creating project directory structure
✓ Generating SSL certificate
✓ Creating MySQL database: my_first_site
✓ Building WordPress container
✓ Starting WordPress container
✓ Installing WordPress
✓ Creating admin user (admin/admin)
✓ Initializing git repository
✓ Creating custom theme: my-first-site-theme
✓ Creating custom plugin: my-first-site-app
✓ Installing git hooks
✓ Indexing codebase for AI search

Project starts automatically. No need to run wdg start.

Accessing Your Site

Open your browser and go to:

https://my-first-site.localhost:8443

You'll see a browser warning about the SSL certificate (see SSL Certificates section above). Click "Advanced" → "Proceed" to continue.

URL:      https://my-first-site.localhost:8443/wp-admin
Username: admin
Password: admin

Security Note: Change the default password in Settings → Users before deploying to production. These defaults are for local development only.

Managing Projects

Starting and Stopping Projects

Your project started automatically when created. You can stop and start it anytime:

bash

# Stop a project (keeps all data)
wdg stop my-first-site

# Start it again
wdg start my-first-site

# Restart a project
wdg restart my-first-site

Why stop projects? Frees up system resources (RAM/CPU). Data and databases are preserved.

Viewing All Projects

bash

wdg list

Shows all projects with status:

Projects:
my-first-site       ✓ Running    https://my-first-site.localhost:8443
client-project      ✗ Stopped    https://client-project.localhost:8443
staging-site        ✓ Running    https://staging-site.localhost:8443

Running Multiple Projects

You can run unlimited projects simultaneously. Each gets:

Its own subdomain URL
Isolated WordPress installation
Separate MySQL database
Independent container

No conflicts. No interference.

bash

# All running at the same time:
wdg start my-first-site      # https://my-first-site.localhost:8443
wdg start client-project     # https://client-project.localhost:8443
wdg start staging-site       # https://staging-site.localhost:8443

Deleting a Project

⚠️ Warning: This permanently deletes the project, database, and all files.

bash

# With confirmation prompt
wdg delete my-first-site

# Skip confirmation (use carefully!)
wdg delete my-first-site --force

What gets deleted:

WordPress container
MySQL database
All files in projects/my-first-site/
SSL certificate
Nginx configuration

What's preserved:

Nothing. Make backups first if you need the data.

Working with Your Project

Indexing Your Code for AI Search

If you created a project with --init-wikit, your code is already indexed and auto-indexes on every git commit.

For basic projects, index manually:

bash

wdg index my-first-site

What this does: Processes your theme and plugin code through the local AI model, creating searchable vectors in the Qdrant database.

When to reindex:

After adding new plugins
After making significant code changes (if not using git)
If AI search results seem outdated

Collection name: Your project's code is stored in a collection named project_my_first_site (underscores replace hyphens).

Using WordPress CLI (WP-CLI)

Run any WordPress CLI command in your project:

bash

# General syntax
wdg my-first-site wp <command>

# Examples:
wdg my-first-site wp plugin list
wdg my-first-site wp theme activate my-first-site-theme
wdg my-first-site wp user list
wdg my-first-site wp post list
wdg my-first-site wp cache flush

What this does: Executes WP-CLI commands inside the WordPress Docker container. No need to SSH into the container.

Database Operations

Export database:

bash

# Export to file with timestamp
wdg my-first-site db export

# Export to specific file
wdg my-first-site db export backup-20250114.sql

Saves to: projects/my-first-site/backups/

Import database:

bash

wdg my-first-site db import backup-20250114.sql

Search and replace in database:

bash

# Change URLs (useful after importing production database)
wdg my-first-site db search-replace https://production.com https://my-first-site.localhost:8443

Reset database (fresh WordPress install):

bash

wdg my-first-site db reset

⚠️ Warning: Deletes all content and reinstalls WordPress.

System Architecture Diagram

Here's how all the pieces fit together:

%%{init: {'theme':'neutral'}}%%
graph LR
    Browser[Your Browser]
    Claude[Claude Desktop]
    CLI[wdg Command]

    subgraph Docker["Docker Services (Isolated Containers)"]
        Nginx[Nginx Reverse Proxy<br/>Routes by subdomain]
        MySQL[(MySQL Database<br/>All project data)]
        Qdrant[(Qdrant Vector DB<br/>Searchable code)]
        MCP[MCP Server<br/>AI code search API]
        Indexer[Indexer Service<br/>Local AI model]
        WP1[my-first-site<br/>WordPress + PHP]
        WP2[another-site<br/>WordPress + PHP]
    end

    Browser -->|:8443 HTTPS| Nginx
    Claude -->|:8765| MCP
    CLI -->|commands| Nginx
    CLI -->|index command| Indexer
    Indexer -->|stores vectors| Qdrant
    Nginx -->|routes requests| WP1
    Nginx -->|routes requests| WP2
    WP1 -->|reads/writes| MySQL
    WP2 -->|reads/writes| MySQL
    MCP -->|searches| Qdrant

External Ports (accessible from your computer):

:8443 - HTTPS websites (via Nginx)
:8880 - HTTP websites (via Nginx)
:3307 - MySQL (use TablePlus, Sequel Pro, etc.)
:6333 - Qdrant dashboard
:8765 - MCP server
:3000 - Web dashboard

Directory Structure Explained

After installation and creating your first project, here's what you have:

WDG-AI-Development-Environment/          # ← You are here
├── cli/
│   └── wdg                              # CLI command script
│
├── projects/                             # All WordPress sites
│   └── my-first-site/                   # Your project container
│       ├── docker-compose.yml           # Docker config for this project
│       ├── .wp-content-link             # Links to git repo (contains: my-first-site)
│       ├── backups/                     # Database exports saved here
│       ├── logs/                        # WordPress error logs
│       ├── config/                      # WordPress config overrides
│       └── repositories/                # Git repos for this project
│           └── my-first-site/           # The git repository
│               ├── wp-content/          # What WordPress sees
│               │   ├── themes/
│               │   │   └── my-first-site-theme/
│               │   ├── plugins/
│               │   │   └── my-first-site-app/
│               │   └── uploads/         # Media files
│               ├── .git/                # Git history
│               ├── .gitignore
│               ├── CLAUDE.md            # Claude AI context
│               └── .mcp.json            # MCP config
│
├── repositories/                        # Shared framework (central)
│   ├── wikit-core/                      # Available to ALL projects
│   ├── wikit-theme/                     # via Docker volume mounts
│   ├── wikit-facets/
│   └── wikit-app/
│
├── services/                            # Docker service configs
│   ├── nginx/                           # Reverse proxy
│   ├── mysql/                           # Database
│   └── wordpress/                       # WordPress Dockerfile
│
├── mcp-server/                          # AI code search server
├── indexer/                             # Code indexing service
├── dashboard/                           # Web UI (React)
├── data/                                # Persistent data volumes
│   ├── mysql/                           # Database files
│   └── qdrant/                          # Vector database
├── ssl/                                 # SSL certificates
├── docs/                                # This documentation
├── docker-compose.yml                   # Main services config
└── .env                                 # Environment variables

Key paths explained:

Path	What it is	Used for
`cli/wdg`	Command-line tool	All project management
`projects/my-first-site/`	Project container	Settings, config, logs
`projects/my-first-site/repositories/my-first-site/`	Git repo	Your theme/plugin code
`projects/my-first-site/repositories/my-first-site/wp-content/`	WordPress content	What WP sees
`repositories/wikit-*/`	Central framework	Shared across all projects
`data/mysql/`	Database files	Persistent across restarts
`data/qdrant/`	Vector database	AI search index

Environment Configuration

The installer created a .env file in the project root with default settings.

To modify settings:

bash

# Edit the .env file
nano .env
# or
code .env

Key Settings

bash

# Database (applies to all projects)
MYSQL_ROOT_PASSWORD=root
WP_DB_USER=wordpress
WP_DB_PASSWORD=wordpress

# AI Model (for code indexing)
EMBEDDING_MODEL=all-MiniLM-L6-v2

# Optional: Claude Desktop integration
ANTHROPIC_API_KEY=sk-ant-...  # Only needed if using Claude Desktop

Available AI Embedding Models

You can change the model used for code indexing. Edit EMBEDDING_MODEL in .env:

Model	Speed	Quality	Download Size	Vector Dimensions
`all-MiniLM-L6-v2` (default)	⚡ Fast	Good	80MB	384
`all-MiniLM-L12-v2`	Fast	Better	120MB	384
`all-mpnet-base-v2`	Medium	Best	420MB	768

After changing: Restart the indexer service:

bash

docker restart wdg-indexer

Trade-offs:

Smaller models: Faster indexing, less RAM, good for most projects
Larger models: More accurate search, needs more RAM (2GB+)

Next Steps

You now have WordPress running with AI-powered code search! Here's what to explore next:

Learn the Framework

📖 Core Concepts - Understand the platform architecture
📘 Wikit Framework Guide - Learn the 50+ blocks
🎨 Theme Development - Build custom themes

Explore AI Features

🔍 AI Code Search - Master semantic search
🔌 Connect Claude Desktop - AI pair programming
🤖 Use the Dashboard - Visual project management

Build Something

⚡ 5-Minute Quick Start - Create a landing page
🏗️ Development Workflow - Daily development guide
🚀 Deploy to Production - Launch your site

Troubleshooting

Docker Issues

Problem: Docker isn't running

bash

# macOS
open -a Docker

# Linux (systemd)
sudo systemctl start docker

# Linux (non-systemd)
sudo service docker start

# Verify Docker is running
docker ps

Problem: Docker Desktop not found (macOS)

Make sure Docker Desktop is installed and running. You'll see a whale icon in your menu bar.

Problem: Permission denied (Linux)

Add your user to the docker group:

bash

sudo usermod -aG docker $USER
# Log out and back in for this to take effect

Port Conflicts

Problem: Port 8443, 8880, or other service ports already in use

The platform automatically checks for port conflicts before starting services. If you see a port conflict error:

Step 1: Check which ports are in conflict:

bash

wdg ports check

This shows all WDG service ports and identifies conflicts with helpful suggestions.

Step 2: Find available alternative ports:

bash

# Find 5 available ports starting from 8000
wdg ports find 5 8000

# Test a specific port
wdg ports test 9443

Step 3: Configure ports in .env file:

bash

# Edit your .env file
nano .env
# or
code .env

Add or update these port configuration variables:

bash

# Service Ports - Change these to avoid conflicts
NGINX_HTTP_PORT=8880        # Main HTTP port
NGINX_HTTPS_PORT=8443       # Main HTTPS port
MYSQL_PORT=3307             # MySQL database
PHPMYADMIN_PORT=8081        # phpMyAdmin web interface
QDRANT_HTTP_PORT=6333       # Vector database
QDRANT_GRPC_PORT=6334       # Vector database gRPC
INDEXER_PORT=8666           # Code indexing service
MCP_SERVER_PORT=8765        # Claude Desktop integration
DOCS_PORT=5173              # Documentation site
DASHBOARD_FRONTEND_PORT=3000  # Web dashboard
DASHBOARD_BACKEND_PORT=8000   # Dashboard API

Step 4: Restart services with new ports:

bash

wdg restart

Alternative - Manual port detection:

bash

# Find what's using a specific port
lsof -i :8443                    # macOS/Linux
sudo netstat -tlnp | grep 8443   # Linux alternative
netstat -ano | findstr :8443     # Windows PowerShell

See all configured ports:

bash

wdg ports status

Shows all service URLs with your configured ports.

SSL Certificate Issues

Problem: Browser won't accept certificate

Solution: This is normal for self-signed certificates. Click "Advanced" → "Proceed to site" in your browser.

Regenerate certificate (if corrupted):

bash

wdg delete my-first-site --force
wdg create my-first-site --init-wikit

Code Indexing Fails

Problem: wdg index command fails or hangs

Check Qdrant is running:

bash

docker ps | grep qdrant

Should show: wdg-qdrant with status "Up"

If not running:

bash

docker-compose up -d qdrant

Check Indexer is running:

bash

docker ps | grep indexer

Should show: wdg-indexer with status "Up"

Restart services:

bash

docker restart wdg-qdrant
docker restart wdg-indexer

# Then try indexing again
wdg index my-first-site

View indexer logs:

bash

docker logs wdg-indexer --follow

Project Won't Start

Problem: wdg start my-first-site fails

Check project exists:

bash

wdg list

Check Docker resources:

bash

# See if containers exist
docker ps -a | grep my-first-site

# Check logs
docker logs wdg-wp-my-first-site

Nuclear option - rebuild project:

bash

# Export database first if you have data
wdg my-first-site db export rescue-backup.sql

# Delete and recreate
wdg delete my-first-site --force
wdg create my-first-site --init-wikit

# Reimport database
wdg my-first-site db import rescue-backup.sql

Database Connection Fails

Problem: WordPress shows "Error establishing database connection"

Check MySQL is running:

bash

docker ps | grep mysql

Restart MySQL:

bash

docker restart wdg-mysql

# Wait 30 seconds for MySQL to fully start
sleep 30

# Restart your project
wdg restart my-first-site

Check database exists:

bash

docker exec wdg-mysql mysql -uroot -proot -e "SHOW DATABASES;" | grep my_first_site

If not listed, recreate it:

bash

wdg delete my-first-site
wdg create my-first-site

Site is Slow

Problem: WordPress loads slowly or times out

Check system resources:

bash

# How many containers are running?
docker ps | wc -l

# Each WordPress project uses ~500MB RAM
# Stop projects you're not actively using
wdg stop client-project
wdg stop staging-site

Check Docker resource limits (Docker Desktop):

Open Docker Desktop → Settings → Resources
Increase Memory allocation (recommended: 8GB+)
Increase CPU allocation (recommended: 4+ cores)

.localhost Domains Don't Work

Problem: Can't access https://my-first-site.localhost:8443

Try:

http://127.0.0.1:8880 (HTTP direct access)
Add to /etc/hosts:

bash

# macOS/Linux
sudo nano /etc/hosts

# Add this line:
127.0.0.1  my-first-site.localhost

# Windows: Edit C:\Windows\System32\drivers\etc\hosts as Administrator

Browser specific issues:

Chrome: Should work automatically
Firefox: May need network.dns.force-resolve-domain-localhost enabled in about:config
Safari: Should work automatically

Getting Help

Documentation

🐛 Debugging Guide - Advanced troubleshooting
📚 CLI Command Reference - All wdg commands
🏗️ Architecture Overview - How it all works

Community Support

💬 Discord: Join the WDG community for help
🐛 GitHub Issues: Report bugs or request features
📧 Email: support@webdevelopmentgroup.com

Before Asking for Help

Gather this information to speed up support:

bash

# 1. Your system info
docker --version
docker compose version
uname -a  # or on Windows: systeminfo

# 2. Service status
wdg status
docker ps

# 3. Recent logs
docker logs wdg-nginx --tail 50
docker logs wdg-mysql --tail 50
docker logs wdg-indexer --tail 50

# 4. Project specific logs
docker logs wdg-wp-my-first-site --tail 50

Include this output when asking for help.

Congratulations! You now have a fully functional WordPress development environment with AI-powered code search. Start building! 🎉

Getting Started ​

What You're Installing ​

Prerequisites ​

Required Software ​

1. Docker Desktop (Recommended) or Docker Engine ​

2. Git ​

3. Disk Space ​

System Requirements ​

Operating System Notes ​

Windows WSL2 Setup ​

Why WSL2? ​

Installing WSL2 ​

Installation ​

Step 1: Clone the Repository ​

Step 2: Run the Installer ​

What the Installer Does ​

Step 3: Set Up the wdg Command ​

Step 4: Verify Installation ​

Understanding Key Concepts ​

Subdomain Routing ​

SSL Certificates ​

Repository Structure ​

Wikit Framework ​

Vector Database & Semantic Search ​

MCP (Model Context Protocol) ​

Creating Your First Project ​

Option 1: Basic WordPress Site ​

Option 2: Full Wikit Setup (Recommended for New Projects) ​

Comparison Table ​

Creating the Project ​

Accessing Your Site ​

WordPress Admin Login ​

Managing Projects ​

Starting and Stopping Projects ​

Viewing All Projects ​

Running Multiple Projects ​

Deleting a Project ​

Working with Your Project ​

Indexing Your Code for AI Search ​

Using WordPress CLI (WP-CLI) ​

Database Operations ​

System Architecture Diagram ​

Directory Structure Explained ​

Environment Configuration ​

Key Settings ​

Available AI Embedding Models ​

Next Steps ​

Learn the Framework ​

Explore AI Features ​

Build Something ​

Troubleshooting ​

Docker Issues ​

Port Conflicts ​

SSL Certificate Issues ​

Code Indexing Fails ​

Project Won't Start ​

Database Connection Fails ​

Site is Slow ​

.localhost Domains Don't Work ​

Getting Help ​

Documentation ​

Community Support ​

Before Asking for Help ​

Getting Started

What You're Installing

Prerequisites

Required Software

1. Docker Desktop (Recommended) or Docker Engine

2. Git

3. Disk Space

System Requirements

Operating System Notes

Windows WSL2 Setup

Why WSL2?

Installing WSL2

Installation

Step 1: Clone the Repository

Step 2: Run the Installer

What the Installer Does

Step 3: Set Up the `wdg` Command

Step 4: Verify Installation

Understanding Key Concepts

Subdomain Routing

SSL Certificates

Repository Structure

Wikit Framework

Vector Database & Semantic Search

MCP (Model Context Protocol)

Creating Your First Project

Option 1: Basic WordPress Site

Option 2: Full Wikit Setup (Recommended for New Projects)

Comparison Table

Creating the Project

Accessing Your Site

WordPress Admin Login

Managing Projects

Starting and Stopping Projects

Viewing All Projects

Running Multiple Projects

Deleting a Project

Working with Your Project

Indexing Your Code for AI Search

Using WordPress CLI (WP-CLI)

Database Operations

System Architecture Diagram

Directory Structure Explained

Environment Configuration

Key Settings

Available AI Embedding Models

Next Steps

Learn the Framework

Explore AI Features

Build Something

Troubleshooting

Docker Issues

Port Conflicts

SSL Certificate Issues

Code Indexing Fails

Project Won't Start

Database Connection Fails

Site is Slow

.localhost Domains Don't Work

Getting Help

Documentation

Community Support

Before Asking for Help