Security by Design Starter Kit

git clone https://git.adlibo.com/Adlibo/starter-kit.git
cd starter-kit

npm install

cp .env.example .env

# Editer .env avec vos cles API
ADLIBO_API_KEY=al_live_xxx        # Requis
OPENAI_API_KEY=sk-xxx             # ou ANTHROPIC_API_KEY
DATABASE_URL=postgresql://...
NEXTAUTH_SECRET=xxx

npm run dev

starter-kit/
├── src/
│   ├── frontend/          # Interface chatbot Next.js
│   │   ├── components/    # Composants UI
│   │   ├── hooks/         # React hooks
│   │   └── pages/         # Routes
│   ├── backend/           # API server
│   │   ├── routes/        # Endpoints API
│   │   ├── services/      # Logique metier
│   │   └── middleware/    # Auth, rate limiting
│   ├── rag/               # Implementation RAG
│   │   ├── embeddings/    # Generation embeddings
│   │   ├── vectorstore/   # Base vectorielle
│   │   └── retrieval/     # Recherche semantique
│   └── mcp/               # Connecteurs MCP
│       ├── tools/         # Definitions d'outils
│       └── handlers/      # Gestionnaires d'actions
├── docs/                  # Documentation educative
├── examples/              # Configurations exemples
└── .github/               # Workflows CI/CD

// app/api/chat/route.ts
import { Adlibo } from '@adlibo/sdk';
import { OpenAI } from 'openai';

const adlibo = new Adlibo(process.env.ADLIBO_API_KEY!);
const openai = new OpenAI();

export async function POST(req: Request) {
  const { message } = await req.json();

  // 1. Analyse sécurité Adlibo
  const security = await adlibo.analyze(message);
  if (security.blocked) {
    return Response.json({ error: security.categories[0]?.name }, { status: 403 });
  }

  // 2. Appel LLM sécurisé
  const stream = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [{ role: 'user', content: security.sanitized || message }],
    stream: true,
  });

  return new Response(stream.toReadableStream());
}

// server.js
const express = require('express');
const { Adlibo } = require('@adlibo/sdk');
const OpenAI = require('openai');

const app = express();
const adlibo = new Adlibo(process.env.ADLIBO_API_KEY);
const openai = new OpenAI();

app.post('/api/chat', async (req, res) => {
  const { message } = req.body;

  // Analyse sécurité
  const security = await adlibo.analyze(message);
  if (security.blocked) {
    return res.status(403).json({ error: 'Blocked', reason: security.categories[0]?.name });
  }

  // Stream response
  res.setHeader('Content-Type', 'text/event-stream');
  const stream = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [{ role: 'user', content: security.sanitized || message }],
    stream: true,
  });

  for await (const chunk of stream) {
    res.write(`data: ${JSON.stringify(chunk)}\n\n`);
  }
  res.end();
});

app.listen(3000);

# main.py
from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from adlibo import Adlibo
from openai import OpenAI
import os

app = FastAPI()
adlibo = Adlibo(os.getenv("ADLIBO_API_KEY"))
openai_client = OpenAI()

@app.post("/api/chat")
async def chat(message: str):
    # Analyse sécurité
    security = adlibo.analyze(message)
    if security.blocked:
        raise HTTPException(403, detail=security.categories[0].name)

    # Stream response
    async def generate():
        stream = openai_client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": security.sanitized or message}],
            stream=True,
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield f"data: {chunk.choices[0].delta.content}\n\n"

    return StreamingResponse(generate(), media_type="text/event-stream")

<!-- Chat.vue -->
<script setup lang="ts">
import { ref } from 'vue';

const message = ref('');
const response = ref('');
const loading = ref(false);

async function sendMessage() {
  loading.value = true;
  response.value = '';

  const res = await fetch('/api/chat', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ message: message.value }),
  });

  if (!res.ok) {
    const error = await res.json();
    alert(`Bloqué: ${error.reason}`);
    loading.value = false;
    return;
  }

  const reader = res.body?.getReader();
  const decoder = new TextDecoder();

  while (true) {
    const { done, value } = await reader!.read();
    if (done) break;
    response.value += decoder.decode(value);
  }
  loading.value = false;
}
</script>

<template>
  <div class="chat">
    <textarea v-model="message" placeholder="Votre message..." />
    <button @click="sendMessage" :disabled="loading">Envoyer</button>
    <div class="response">{{ response }}</div>
  </div>
</template>

# app.py
from flask import Flask, request, jsonify, Response
from adlibo import Adlibo
from openai import OpenAI
import os

app = Flask(__name__)
adlibo = Adlibo(os.getenv("ADLIBO_API_KEY"))
openai_client = OpenAI()

@app.route("/api/chat", methods=["POST"])
def chat():
    message = request.json.get("message")

    # Analyse sécurité
    security = adlibo.analyze(message)
    if security.blocked:
        return jsonify({"error": security.categories[0].name}), 403

    def generate():
        stream = openai_client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": security.sanitized or message}],
            stream=True,
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield f"data: {chunk.choices[0].delta.content}\n\n"

    return Response(generate(), mimetype="text/event-stream")

if __name__ == "__main__":
    app.run(port=3000)

// Scanner les documents recuperes pour injections indirectes
const context = await retrieveContext(query);

const contextSecurity = await adlibo.analyze(context);
if (contextSecurity.score > 50) {
  console.warn('Suspicious content in retrieved documents');
  // Filtrer ou ignorer le document suspect
}

// src/mcp/tools/index.ts
export const tools = [
  {
    name: 'query_database',
    description: 'Execute a read-only SQL query',
    input_schema: {
      type: 'object',
      properties: {
        query: { type: 'string', description: 'SQL SELECT query' },
        limit: { type: 'number', description: 'Max rows (default: 10)' }
      },
      required: ['query']
    }
  },
  {
    name: 'search_documents',
    description: 'Search internal documents by keyword',
    input_schema: {
      type: 'object',
      properties: {
        query: { type: 'string' },
        department: { type: 'string' }
      },
      required: ['query']
    }
  },
  {
    name: 'send_email',
    description: 'Send an email to a colleague',
    input_schema: {
      type: 'object',
      properties: {
        to: { type: 'string' },
        subject: { type: 'string' },
        body: { type: 'string' }
      },
      required: ['to', 'subject', 'body']
    }
  }
];