Files
leocrm/docs/plugin-development-guide.md
T

349 lines
10 KiB
Markdown
Raw Normal View History

2026-07-23 08:42:26 +02:00
# LeoCRM Plugin Development Guide
> **Version:** 1.0
> **Datum:** 2026-07-23
> **Gültig für:** Alle Plugin-Entwickler
---
## 1. Plugin-Struktur
Jedes Plugin liegt unter `app/plugins/builtins/<plugin_name>/`:
```
app/plugins/builtins/my_plugin/
├── __init__.py
├── plugin.py # Plugin-Klasse mit Manifest
├── routes.py # API-Routes
├── models.py # SQLAlchemy-Modelle (optional)
├── schemas.py # Pydantic-Schemas (optional)
├── services.py # Business-Logik (optional)
├── migrations/ # SQL-Migrationen
│ └── 0001_initial.sql
└── tests/ # Plugin-Tests (optional)
```
## 2. Plugin-Manifest
Das Manifest definiert Metadaten, Abhängigkeiten, Routes, Events und Permissions:
```python
from app.plugins.base import BasePlugin
from app.plugins.manifest import PluginManifest, PluginRouteDef
class MyPlugin(BasePlugin):
manifest = PluginManifest(
name="my_plugin",
version="1.0.0",
display_name="My Plugin",
description="Description of what the plugin does.",
dependencies=["permissions"], # Other plugins this depends on
routes=[
PluginRouteDef(
path="/api/v1/my-plugin",
module="app.plugins.builtins.my_plugin.routes",
router_attr="router",
),
],
events=["contact.created", "contact.updated"],
migrations=["0001_initial.sql"],
permissions=[
"my_plugin:read",
"my_plugin:write",
"my_plugin:delete",
],
agent_capabilities=[
"my_plugin:search",
"my_plugin:analyze",
],
)
```
### Manifest-Felder
| Feld | Typ | Pflicht | Beschreibung |
|---|---|---|---|
| `name` | `str` | Ja | Eindeutiger Plugin-Name (snake_case) |
| `version` | `str` | Ja | Semantic Version |
| `display_name` | `str` | Ja | Anzeigename |
| `description` | `str` | Nein | Kurzbeschreibung |
| `dependencies` | `list[str]` | Nein | Andere Plugins, die geladen sein müssen |
| `routes` | `list[PluginRouteDef]` | Nein | API-Routen-Definitionen |
| `events` | `list[str]` | Nein | Events, die das Plugin abonniert |
| `migrations` | `list[str]` | Nein | SQL-Migrationsdateien |
| `permissions` | `list[str]` | Nein | RBAC-Permissions, die das Plugin definiert |
| `field_definitions` | `list[FieldDefinition]` | Nein | Feld-Level-Permissions |
| `agent_capabilities` | `list[str]` | Nein | KI-Agent-Fähigkeiten, die das Plugin bietet |
| `is_core` | `bool` | Nein | Core-Plugin (kann nicht deaktiviert werden) |
## 3. RBAC-Permissions
### Permissions definieren
Im Manifest werden alle Permissions des Plugins aufgelistet:
```python
permissions=[
"my_plugin:read",
"my_plugin:write",
"my_plugin:delete",
"my_plugin:admin",
],
```
### Routes absichern
Jede Route muss mit `require_permission` abgesichert werden:
```python
from app.deps import get_current_user, require_permission
from fastapi import Depends
@router.get("", dependencies=[Depends(require_permission("my_plugin:read"))])
async def list_items(current_user: dict = Depends(get_current_user)):
...
@router.post("", status_code=201, dependencies=[Depends(require_permission("my_plugin:write"))])
async def create_item(data: ItemCreate, current_user: dict = Depends(get_current_user)):
...
@router.delete("/{item_id}", dependencies=[Depends(require_permission("my_plugin:delete"))])
async def delete_item(item_id: str, current_user: dict = Depends(get_current_user)):
...
```
### Permission-Namenskonvention
- Format: `<plugin_name>:<action>`
- Standard-Actions: `read`, `write`, `delete`, `share`, `admin`
- Beispiele: `calendar:read`, `dms:write`, `tags:delete`
## 4. KI-Agent-Framework
LeoCRM bietet ein integriertes KI-Agent-Framework basierend auf **LiteLLM** und **PydanticAI**.
### Architektur
```
Plugin (ai_assistant, ai_proactive, zukünftige)
LiteLLM (unified LLM interface — 100+ Provider)
Provider (OpenAI, Anthropic, Google, Ollama, ...)
Tool Registry (Plugin-Tools für KI-Agenten)
```
### LiteLLM — Unified LLM Interface
LiteLLM bietet eine einheitliche API für über 100 LLM-Provider. Alle KI-Funktionen
in LeoCRM nutzen `litellm.acompletion()`:
```python
import litellm
response = await litellm.acompletion(
model="openai/gpt-4o", # oder anthropic/claude-3-sonnet, ollama/llama3
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_query},
],
temperature=0.3,
max_tokens=1000,
api_key=os.environ.get("AI_API_KEY"),
api_base=os.environ.get("AI_API_BASE"), # optional für self-hosted
)
content = response.choices[0].message.content
```
### Konfiguration
| Env-Var | Beschreibung | Standard |
|---|---|---|
| `AI_MODEL` | Modell-Name (z.B. `gpt-4o`, `claude-3-sonnet`, `llama3`) | — |
| `AI_API_KEY` | API-Key für den Provider | — |
| `AI_API_BASE` | Custom API-Base-URL (optional) | Provider-Standard |
| `AI_PROVIDER` | Provider-Präfix (`openai`, `anthropic`, `google`, `ollama`) | `openai` |
Wenn `AI_MODEL` und `AI_API_KEY` nicht gesetzt sind, läuft der LLM-Client im Mock-Modus
(keyword-basierte Action-Mapping für Tests).
### Tool Registry — KI-Tools registrieren
Plugins können Tools registrieren, die KI-Agenten während Chat-Sessions aufrufen können.
Jedes Tool deklariert Name, Beschreibung, JSON-Schema für Parameter und einen async Handler.
```python
from app.plugins.builtins.ai_assistant.tool_registry import get_tool_registry
registry = get_tool_registry()
registry.register(
name="search_contacts",
description="Search contacts by name, email, or phone number",
parameters={
"type": "object",
"properties": {
"query": {"type": "string", "description": "Search query"},
"limit": {"type": "integer", "description": "Max results", "default": 10},
},
"required": ["query"],
},
handler=my_search_handler,
plugin_name="my_plugin",
required_permission="contacts:read",
category="search",
)
```
### Tool Handler
Der Handler ist eine async Funktion, die Argumente und Kontext empfängt:
```python
async def my_search_handler(arguments: dict, context: dict) -> str:
query = arguments.get("query", "")
limit = arguments.get("limit", 10)
# ... perform search ...
return json.dumps({"results": results})
```
### Tools bei Plugin-Deaktivierung abmelden
```python
def on_deactivate(self):
registry = get_tool_registry()
registry.unregister_plugin("my_plugin")
```
### Agent Capabilities im Manifest
Das `agent_capabilities` Feld im Manifest deklariert, welche KI-Fähigkeiten ein Plugin bietet:
```python
agent_capabilities=[
"contact_search", # Kontakt-Suche
"email_draft", # E-Mail-Entwürfe generieren
"calendar_scheduling", # Terminvorschläge
],
```
Diese Informationen werden vom AI Assistant verwendet, um Nutzern zu zeigen,
welche KI-Funktionen verfügbar sind.
## 5. Events
Plugins können Events abonnieren und auslösen:
```python
# Im Manifest:
events=["contact.created", "contact.updated", "contact.deleted"]
# Event-Handler im Plugin:
async def on_contact_created(self, event_data: dict):
# Reagiere auf neues Kontakt-Event
pass
```
Events werden vom Event-Publisher im Contact-Service ausgelöst:
```python
from app.core.events import publish_event
await publish_event(db, "contact.created", {"contact_id": str(contact.id)})
```
## 6. Datenbank-Migrationen
SQL-Migrationen liegen unter `migrations/` im Plugin-Verzeichnis:
```sql
-- migrations/0001_initial.sql
CREATE TABLE my_plugin_items (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
tenant_id UUID NOT NULL REFERENCES tenants(id),
name VARCHAR(200) NOT NULL,
created_at TIMESTAMP DEFAULT NOW(),
updated_at TIMESTAMP DEFAULT NOW()
);
```
Im Manifest referenzieren:
```python
migrations=["0001_initial.sql"]
```
## 7. UI-Integration
Siehe `docs/ui-design-guidelines.md` für Frontend-Konventionen.
- Plugin-Seiten verwenden das 3-Spalten-Explorer-Layout
- PluginToolbar für Aktionen
- Plugin-Settings als eigene Settings-Sub-Seite
- i18n-Keys mit Plugin-Präfix
## 8. Testing
Tests liegen unter `tests/` im Plugin-Verzeichnis oder im zentralen `tests/` Ordner:
```python
# tests/test_my_plugin.py
import pytest
from httpx import AsyncClient
@pytest.mark.asyncio
async def test_list_items_requires_permission(client: AsyncClient, auth_headers):
response = await client.get("/api/v1/my-plugin", headers=auth_headers)
assert response.status_code == 200
@pytest.mark.asyncio
async def test_list_items_without_permission_returns_403(client: AsyncClient, no_perm_headers):
response = await client.get("/api/v1/my-plugin", headers=no_perm_headers)
assert response.status_code == 403
```
## 9. Plugin-Beispiel
Minimal-Beispiel für ein neues Plugin:
```python
# app/plugins/builtins/my_plugin/plugin.py
from app.plugins.base import BasePlugin
from app.plugins.manifest import PluginManifest, PluginRouteDef
class MyPlugin(BasePlugin):
manifest = PluginManifest(
name="my_plugin",
version="1.0.0",
display_name="My Plugin",
description="A minimal example plugin.",
dependencies=[],
routes=[
PluginRouteDef(
path="/api/v1/my-plugin",
module="app.plugins.builtins.my_plugin.routes",
router_attr="router",
),
],
events=[],
migrations=[],
permissions=["my_plugin:read", "my_plugin:write"],
agent_capabilities=[],
)
```
```python
# app/plugins/builtins/my_plugin/routes.py
from fastapi import APIRouter, Depends
from app.deps import get_current_user, require_permission
router = APIRouter()
@router.get("", dependencies=[Depends(require_permission("my_plugin:read"))])
async def list_items(current_user: dict = Depends(get_current_user)):
return {"items": []}
```
---
*Dieses Dokument ist verbindlich für alle Plugin-Entwicklung an LeoCRM.*