Bij mijn dagelijkse ontwikkelwerk kom ik regelmatig code tegen die slecht gedocumenteerd is of waarvan de logica niet direct duidelijk wordt. Het handmatig doorlezen en begrijpen van legacy code kost enorm veel tijd. Daarom ben ik begonnen met het bouwen van lokale AI agents die mijn code kunnen analyseren, documenteren en zelfs suggesties voor verbeteringen kunnen geven. Met Ollama draai ik deze agents volledig lokaal, zonder dat gevoelige code mijn machine verlaat.
Code analysis agent opzetten
Mijn eerste AI agent focust zich op het analyseren van PHP code en het genereren van documentatie. De basis hiervan is een simpel Python script dat communiceert met Ollama via de REST API. Het model dat ik hiervoor inzet is CodeLlama, een gespecialiseerd model voor programmeercode.
import requests
import json
import os
class CodeAnalysisAgent:
def __init__(self, model_name="codellama:7b"):
self.base_url = "http://localhost:11434"
self.model = model_name
def analyze_file(self, file_path):
with open(file_path, 'r') as file:
code_content = file.read()
prompt = f"""
Analyseer deze PHP code en geef een gestructureerde analyse:
1. Beschrijf wat de code doet
2. Identificeer mogelijke problemen
3. Suggereer verbeteringen
Code:
{code_content}
"""
response = requests.post(f"{self.base_url}/api/generate",
json={
"model": self.model,
"prompt": prompt,
"stream": False
})
return response.json()['response']
agent = CodeAnalysisAgent()
analysis = agent.analyze_file('src/UserController.php')
print(analysis)
Deze agent draait volledig op mijn lokale machine. Geen externe API calls, geen data die naar servers van grote techbedrijven gaat. Het model downloadt zich automatisch de eerste keer dat je het aanroept, wat een paar gigabyte kan zijn afhankelijk van welk model je kiest.
Wat opvalt is dat CodeLlama verrassend goed is in het herkennen van patronen in mijn Laravel projecten. Het herkent Eloquent models, middleware structuren en zelfs specifieke design patterns die ik toepas. Het model geeft nuttige suggesties zoals het toevoegen van type hints, het verbeteren van error handling en het identificeren van mogelijke N+1 query problemen.
Documentatie generatie automatiseren
Naast code analyse heb ik een tweede agent gebouwd die automatisch documentatie genereert voor mijn API endpoints. Dit scheelt me uren werk bij het updaten van API specs wanneer ik wijzigingen doorvoer in mijn Laravel controllers.
class DocumentationAgent:
def __init__(self):
self.model = "codellama:7b"
self.base_url = "http://localhost:11434"
def generate_api_docs(self, controller_path):
with open(controller_path, 'r') as file:
controller_code = file.read()
prompt = f"""
Genereer OpenAPI 3.0 documentatie voor deze Laravel controller.
Focus op de publieke methodes en hun parameters.
Controller code:
{controller_code}
Output format: YAML
"""
response = requests.post(f"{self.base_url}/api/generate",
json={
"model": self.model,
"prompt": prompt,
"stream": False
})
return response.json()['response']
def batch_process_controllers(self, controllers_dir):
docs = {}
for filename in os.listdir(controllers_dir):
if filename.endswith('Controller.php'):
file_path = os.path.join(controllers_dir, filename)
docs[filename] = self.generate_api_docs(file_path)
return docs
doc_agent = DocumentationAgent()
all_docs = doc_agent.batch_process_controllers('app/Http/Controllers')
De kwaliteit van de gegenereerde documentatie is behoorlijk hoog. Het model begrijpt Laravel-specifieke concepten zoals form request validation, resource transformaties en middleware. Soms moet ik nog handmatig aanpassingen maken, maar het geeft me een sterke basis om vanaf te werken.
Een interessant aspect is hoe goed het model omgaat met Nederlandse commentaar in mijn code. Ik schrijf vaak comments in het Nederlands, en de AI agent weet deze te interpreteren en mee te nemen in de gegenereerde Engelstalige documentatie. Het vertaalwerk gebeurt automatisch en is meestal accuraat.
Performance optimalisatie en resource management
Het draaien van AI modellen lokaal vereist behoorlijk wat systeembronnen. CodeLlama 7B heeft ongeveer 8GB RAM nodig, en de response tijd ligt tussen de 10-30 seconden afhankelijk van de complexiteit van de vraag. Voor mijn workflow is dit acceptabel omdat ik de agents batch-gewijs inzet, bijvoorbeeld aan het einde van de dag of tijdens pauzes.
# Ollama model management
ollama list
ollama pull codellama:13b
ollama rm codellama:7b
# Performance monitoring
ollama show codellama:7b --verbose
htop # Monitor RAM usage tijdens model execution
Wat ik ontdekt heb is dat het 13B model aanzienlijk betere resultaten geeft voor complexere code analyse, maar wel veel meer geheugen vereist. Voor simpele documentatie taken is het 7B model voldoende. Ik wissel tussen modellen afhankelijk van wat ik aan het doen ben.
Resource management wordt cruciaal wanneer je meerdere agents tegelijk wilt draaien. Ollama beheert dit redelijk goed door models automatisch uit het geheugen te halen wanneer ze niet actief zijn. Toch monitor ik mijn systeemprestaties zorgvuldig, vooral tijdens intensieve analyse sessies.
Integratie in development workflow
Mijn AI agents zijn nu geïntegreerd in mijn dagelijkse workflow via een simpel bash script dat ik aanroep vanuit mijn IDE. Het script analyseert gewijzigde bestanden sinds de laatste commit en genereert automatisch documentatie updates.
#!/bin/bash
# ai-analysis.sh
# Get changed files since last commit
CHANGED_FILES=$(git diff --name-only HEAD~1)
# Filter PHP files
PHP_FILES=$(echo "$CHANGED_FILES" | grep '\.php$')
if [ -n "$PHP_FILES" ]; then
echo "Analyzing changed PHP files..."
python3 /path/to/code_analysis.py $PHP_FILES
# Generate docs for controllers
CONTROLLERS=$(echo "$PHP_FILES" | grep 'Controller\.php$')
if [ -n "$CONTROLLERS" ]; then
python3 /path/to/doc_generation.py $CONTROLLERS
fi
fi
Deze workflow integration heeft mijn productiviteit behoorlijk verhoogd. Vooral bij het werken aan bestaande projecten waar de documentatie achterloopt, geeft het me snel inzicht in wat de code doet en waar mogelijke verbeterpunten zitten.
Het mooie van deze lokale setup is dat ik volledige controle heb over mijn data. Bedrijfsgevoelige code blijft op mijn machine, en ik ben niet afhankelijk van externe diensten die plotseling duurder kunnen worden of hun voorwaarden kunnen wijzigen. De initiele investering in hardware en setup tijd verdient zichzelf terug door de tijd die ik bespaar op handmatige code reviews en documentatie.