ggen 2.7.1

ggen is a deterministic, language-agnostic code generation framework that treats software artifacts as projections of knowledge graphs. 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
**Table of Contents**

- [AI-Powered Generation](#ai-powered-generation)
  - [Prerequisites](#prerequisites)
  - [Step 1: Generate Ontology with AI](#step-1-generate-ontology-with-ai)
  - [Step 2: Review and Refine](#step-2-review-and-refine)
  - [Step 3: Generate Code](#step-3-generate-code)
  - [Step 4: AI-Assisted Analysis](#step-4-ai-assisted-analysis)
  - [AI Features](#ai-features)
    - [Generate Ontology](#generate-ontology)
    - [Interactive Chat](#interactive-chat)
    - [Code Analysis](#code-analysis)
  - [Workflow: AI → Ontology → Code](#workflow-ai-%E2%86%92-ontology-%E2%86%92-code)
  - [Best Practices](#best-practices)
  - [Next Steps](#next-steps)

<!-- END doctoc generated TOC please keep comment here to allow auto update -->

# AI-Powered Generation

**Goal:** Use AI to generate ontologies, refine them, and generate code automatically.

**What you'll learn:** How to leverage AI for rapid ontology creation and code generation.

## Prerequisites

- ggen installed (see [Getting Started](getting-started.md))
- AI API key (Anthropic, OpenAI, or Ollama configured)

## Step 1: Generate Ontology with AI

Describe your domain in natural language:

```bash
ggen ai generate-ontology \
  --prompt "E-commerce platform: Product (name, price, sku), Order (items, total, customer), Customer (name, email, address)" \
  --output domain.ttl
```

AI generates a complete RDF ontology from your description.

## Step 2: Review and Refine

Inspect the generated ontology:

```bash
cat domain.ttl
```

Use AI to refine:

```bash
ggen ai chat \
  --prompt "Add product categories and inventory tracking to domain.ttl" \
  --input domain.ttl \
  --output domain-refined.ttl
```

## Step 3: Generate Code

Generate Rust models:

```bash
ggen template generate-rdf \
  --ontology domain-refined.ttl \
  --template rust-models \
  --output src/models.rs
```

## Step 4: AI-Assisted Analysis

Analyze your codebase and suggest ontology improvements:

```bash
ggen ai analyze src/ \
  --focus domain-model \
  --suggest-ontology-improvements
```

AI suggests ontology changes based on your code patterns.

## AI Features

### Generate Ontology
```bash
ggen ai generate-ontology \
  --prompt "Your domain description" \
  --output domain.ttl
```

### Interactive Chat
```bash
ggen ai chat --interactive
```

### Code Analysis
```bash
ggen ai analyze <path> \
  --focus <aspect> \
  --suggest-improvements
```

## Workflow: AI → Ontology → Code

1. **AI generates ontology** from natural language
2. **Review and refine** ontology (AI-assisted)
3. **Generate code** from ontology
4. **Analyze code** to suggest ontology improvements
5. **Iterate** for continuous improvement

## Best Practices

- Start with AI-generated ontologies, then refine manually
- Use AI analysis to discover missing ontology concepts
- Combine AI generation with manual SPARQL queries for complex domains
- Validate AI-generated ontologies with SHACL before generating code

## Next Steps

- **Learn ontology creation:** [Use RDF Ontologies Guide](../how-to-guides/use-rdf-ontologies.md)
- **CLI reference:** [AI Commands Reference](../reference/cli.md#ai-commands)
- **Understand concepts:** [Ontology-Driven Explanation](../explanations/ontology-driven.md)