01 — Démarrage
Démarrage rapide
Intégrez Cohesif Ultra dans votre application en moins de 5 minutes. Notre API REST est compatible avec le standard OpenAI — migration depuis GPT-4 possible en 10 minutes.
ÉTAPE 1
Installez le SDK
pip ou npm en une ligne
ÉTAPE 2
Ajoutez votre clé API
Variable d'environnement
ÉTAPE 3
Première requête
Réponse en < 500ms
Installation
Installez le SDK officiel Cohesif pour votre langage préféré :
bash — Python
pip install lumis-ai
bash — Node.js
npm install @lumis/sdk
# ou
yarn add @lumis/sdk
Authentification
Toutes les requêtes API nécessitent un Bearer token. Récupérez votre clé depuis le tableau de bord.
Sécurité : Ne commitez jamais votre clé API dans votre code source. Utilisez des variables d'environnement.
bash
export Cohesif_API_KEY="lms-sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
python
import lumis
client = lumis.Client(api_key="lms-sk-...")
# ou automatiquement depuis l'env
client = lumis.Client() # lit Cohesif_API_KEY
typescript
import Lumis from '@lumis/sdk'
const client = new Lumis({
apiKey: process.env.Cohesif_API_KEY,
})
Première requête
python
import lumis
client = lumis.Client()
response = client.chat.completions.create(
model="lumis-ultra",
messages=[
{
"role": "system",
"content": "Tu es un assistant expert en droit français des affaires."
},
{
"role": "user",
"content": "Rédige une clause de non-concurrence conforme au droit français."
}
],
max_tokens=1024,
temperature=0.3,
)
print(response.choices[0].message.content)
typescript
import Lumis from '@lumis/sdk'
const client = new Lumis()
const response = await client.chat.completions.create({
model: 'lumis-ultra',
messages: [
{
role: 'system',
content: 'Tu es un assistant expert en droit français des affaires.',
},
{
role: 'user',
content: 'Rédige une clause de non-concurrence conforme au droit français.',
},
],
max_tokens: 1024,
temperature: 0.3,
})
console.log(response.choices[0].message.content)
Streaming
Activez le streaming pour une expérience utilisateur en temps réel. Cohesif Ultra supporte Server-Sent Events (SSE).
python
with client.chat.completions.stream(
model="lumis-ultra",
messages=[{"role": "user", "content": "Écris un plan business en 5 points"}],
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
typescript
const stream = await client.chat.completions.create({
model: 'lumis-ultra',
messages: [{ role: 'user', content: 'Écris un plan business en 5 points' }],
stream: true,
})
for await (const chunk of stream) {
const delta = chunk.choices[0]?.delta?.content ?? ''
process.stdout.write(delta)
}
03 — Agents
Agents autonomes
Les agents Cohesif sont des entités autonomes capables de décomposer des objectifs complexes, utiliser des outils externes et maintenir un contexte sur plusieurs sessions.
Vue d'ensemble
Les agents Cohesif utilisent un cycle Raisonnement → Action → Observation (RAO). Chaque cycle peut appeler des outils externes (API, bases de données, navigateur) et stocker des informations en mémoire longue durée.
Créer un agent
python
agent = client.agents.create(
name="Prospecteur Commercial",
description="Qualifie les leads LinkedIn et rédige des emails personnalisés",
model="lumis-ultra",
instructions="""Tu es un expert en développement commercial B2B.
Pour chaque lead :
1. Analyse le profil LinkedIn et le site web de l'entreprise
2. Identifie la proposition de valeur la plus pertinente
3. Rédige un email de prospection personnalisé en 150 mots max
""",
tools=["web_search", "send_email", "update_crm"],
memory={
"type": "persistent",
"retention_days": 90,
},
)
python
# Exécuter l'agent
run = client.agents.run(
agent_id=agent.id,
input="Prospecte les 10 CTOs des startups SaaS levées en Série B en France ce mois-ci",
context={
"company": "ACME Corp",
"product": "Logiciel de comptabilité automatisée",
"target_segment": "PME 10-200 salariés",
},
)
# Suivre l'exécution en temps réel
for event in run.stream():
if event.type == "thought":
print(f"[Réflexion] {event.content}")
elif event.type == "action":
print(f"[Action] {event.tool}: {event.input}")
elif event.type == "done":
print(f"[Résultat] {event.output}")
Mémoire longue durée
python
# Stocker des informations en mémoire
client.agents.memory.store(
agent_id=agent.id,
content="Le prospect Jean Dupont (jean@acme.fr) préfère les appels le mardi matin.",
tags=["prospect", "preferences"],
)
# Récupérer des souvenirs pertinents
memories = client.agents.memory.search(
agent_id=agent.id,
query="préférences de contact Jean Dupont",
limit=5,
)
for m in memories:
print(f"[Mémoire] {m.content} (score: {m.relevance:.2f})")
Configuration
json — Payload exemple
{
"id": "evt_01HXYZ...",
"type": "agent.run.completed",
"created": 1704067200,
"data": {
"agent_id": "agt_abc123",
"run_id": "run_xyz789",
"status": "completed",
"tokens_used": 4821,
"duration_ms": 12400,
"output": "..."
}
}
Événements disponibles
agent.run.startedUne exécution d'agent a démarré
agent.run.completedUne exécution d'agent s'est terminée avec succès
agent.run.failedUne exécution d'agent a échoué
chat.completion.createdUne completion a été générée
usage.limit.approachingSeuil de consommation à 80%
billing.invoice.paidFacture réglée avec succès
Vérifier la signature
python
import hmac
import hashlib
def verify_webhook(payload: bytes, signature: str, secret: str) -> bool:
"""Vérifie la signature HMAC-SHA256 du webhook."""
expected = hmac.new(
secret.encode(),
payload,
hashlib.sha256
).hexdigest()
return hmac.compare_digest(f"sha256={expected}", signature)
# Dans votre handler Flask/FastAPI :
@app.post("/webhook/lumis")
async def handle_webhook(request: Request):
payload = await request.body()
signature = request.headers.get("X-Lumis-Signature")
if not verify_webhook(payload, signature, os.getenv("Cohesif_WEBHOOK_SECRET")):
raise HTTPException(status_code=401, detail="Signature invalide")
event = json.loads(payload)
# Traiter l'événement...