Modèles d'Intégration d'Entreprise¶
Ce guide fournit des informations complètes pour les organisations cherchant à intégrer les capacités de gestion des connaissances et de recherche sémantique de Rememberizer dans des environnements d'entreprise. Il couvre les modèles architecturaux, les considérations de sécurité, la scalabilité et les meilleures pratiques.
Aperçu de l'intégration d'entreprise¶
Rememberizer offre des capacités d'intégration d'entreprise robustes qui vont au-delà de l'utilisation de base des API, permettant aux organisations de construire des systèmes de gestion des connaissances sophistiqués qui :
- S'adaptent aux besoins organisationnels à travers les départements et les équipes
- Maintiennent la sécurité et la conformité avec les exigences de l'entreprise
- S'intègrent aux systèmes existants et aux outils de flux de travail
- Permettent le contrôle d'accès basé sur l'équipe et le partage des connaissances
- Supportent des opérations par lots à fort volume pour le traitement des documents
Modèles Architecturaux pour l'Intégration d'Entreprise¶
1. Gestion des Connaissances Multi-Tenant¶
Les organisations peuvent mettre en œuvre une architecture multi-tenant pour organiser les connaissances par équipes, départements ou fonctions :
┌───────────────┐
│ Rememberizer│
│ Platform │
└───────┬───────┘
│
┌─────────────────┼─────────────────┐
│ │ │
┌───────▼────────┐ ┌──────▼───────┐ ┌───────▼────────┐
│ Base de │ │ Ventes │ │ Juridique │
│ Connaissances │ │ Base de │ │ Base de │
│ Ingénierie │ │ Connaissances │ │ Connaissances │
└───────┬────────┘ └──────┬───────┘ └───────┬────────┘
│ │ │
│ │ │
┌───────▼────────┐ ┌──────▼───────┐ ┌───────▼────────┐
│ Mementos │ │ Mementos │ │ Mementos │
│ spécifiques │ │ spécifiques │ │ spécifiques │
└────────────────┘ └──────────────┘ └─────────────────┘
Étapes de Mise en Œuvre : 1. Créer des magasins de vecteurs séparés pour chaque département ou domaine de connaissance majeur 2. Configurer le contrôle d'accès basé sur l'équipe en utilisant la fonctionnalité d'équipe de Rememberizer 3. Définir des mementos pour contrôler l'accès à des sous-ensembles de connaissances spécifiques 4. Mettre en œuvre des autorisations basées sur les rôles pour les administrateurs de connaissances et les consommateurs
2. Architecture du Hub d'Intégration¶
Pour les entreprises disposant de systèmes existants, le modèle hub-and-spoke permet à Rememberizer d'agir en tant que référentiel central de connaissances :
┌─────────────┐ ┌─────────────┐
│ Système CRM │ │ Système ERP │
└──────┬──────┘ └──────┬──────┘
│ │
│ │
▼ ▼
┌──────────────────────────────────────────┐
│ │
│ Bus de Service d'Entreprise │
│ │
└────────────────────┬─────────────────────┘
│
▼
┌───────────────────┐
│ Rememberizer │
│ Plateforme de Connaissances │
└─────────┬─────────┘
│
┌─────────────────┴────────────────┐
│ │
┌─────────▼──────────┐ ┌──────────▼────────┐
│ Base de Connaissances │ │ Base de Connaissances Client │
│ Interne │ │ Externe │
└────────────────────┘ └─────────────────────┘
Étapes de Mise en Œuvre : 1. Créer et configurer des clés API pour l'intégration système à système 2. Mettre en œuvre OAuth2 pour l'accès basé sur l'utilisateur aux référentiels de connaissances 3. Configurer des processus ETL pour la synchronisation régulière des connaissances 4. Utiliser des webhooks pour notifier les systèmes externes des mises à jour de connaissances
3. Architecture des Microservices¶
Pour les organisations adoptant des microservices, intégrez Rememberizer en tant que service de connaissance spécialisé :
┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Service Utilisateur│ │ Service Auth│ │ Service Données│ │ Interface Recherche│
└──────┬──────┘ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘
│ │ │ │
└────────────────┼────────────────┼────────────────┘
│ │
▼ ▼
┌─────────────────────────────────┐
│ Passerelle API │
└─────────────────┬─────────────┘
│
▼
┌───────────────────┐
│ Rememberizer │
│ API de Connaissance│
└───────────────────┘
Étapes de Mise en Œuvre : 1. Créer des comptes de service dédiés pour l'intégration des microservices 2. Mettre en œuvre une authentification basée sur des tokens JWT pour la communication entre services 3. Concevoir des interactions API idempotentes pour la résilience 4. Mettre en œuvre des disjoncteurs pour la tolérance aux pannes
Modèles de Sécurité d'Entreprise¶
Authentification et Autorisation¶
Rememberizer prend en charge plusieurs méthodes d'authentification adaptées aux environnements d'entreprise :
1. Intégration OAuth2¶
Pour un accès basé sur l'utilisateur, implémentez le flux d'autorisation OAuth2 :
// Étape 1 : Rediriger les utilisateurs vers le point de terminaison d'autorisation de Rememberizer
function redirectToAuth() {
const authUrl = 'https://api.rememberizer.ai/oauth/authorize/';
const params = new URLSearchParams({
client_id: 'YOUR_CLIENT_ID',
redirect_uri: 'YOUR_REDIRECT_URI',
response_type: 'code',
scope: 'read write'
});
window.location.href = `${authUrl}?${params.toString()}`;
}
// Étape 2 : Échanger le code d'autorisation contre des jetons
async function exchangeCodeForTokens(code) {
const tokenUrl = 'https://api.rememberizer.ai/oauth/token/';
const response = await fetch(tokenUrl, {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
client_id: 'YOUR_CLIENT_ID',
client_secret: 'YOUR_CLIENT_SECRET',
grant_type: 'authorization_code',
code: code,
redirect_uri: 'YOUR_REDIRECT_URI'
})
});
return response.json();
}
2. Authentification par Compte de Service¶
Pour l'intégration système à système, utilisez l'authentification par clé API :
import requests
def search_knowledge_base(query, api_key):
headers = {
'X-API-Key': api_key,
'Content-Type': 'application/json'
}
payload = {
'query': query,
'num_results': 10
}
response = requests.post(
'https://api.rememberizer.ai/api/v1/search/',
headers=headers,
json=payload
)
return response.json()
3. SAML et SSO d'entreprise¶
Pour l'intégration du SSO d'entreprise :
- Configurez votre fournisseur d'identité (Okta, Azure AD, etc.) pour reconnaître Rememberizer comme fournisseur de services
- Configurez le mappage des attributs SAML pour correspondre aux attributs utilisateur de Rememberizer
- Configurez Rememberizer pour déléguer l'authentification à votre fournisseur d'identité
Modèle de Sécurité Zero Trust¶
Implémentez une approche zero trust avec Rememberizer en :
- Micro-segmentation : Créez des bases de connaissances séparées avec des contrôles d'accès distincts
- Vérification Continue : Mettez en œuvre des jetons à courte durée de vie et une réauthentification régulière
- Moindre Privilège : Définissez des mementos granulaires qui limitent l'accès à des sous-ensembles de connaissances spécifiques
- Journalisation des Événements : Surveillez et auditez tous les accès aux connaissances sensibles
Modèles de Scalabilité¶
Traitement par lots pour l'ingestion de documents¶
Pour l'ingestion de documents à grande échelle, implémentez le modèle de téléchargement par lots :
import requests
import time
from concurrent.futures import ThreadPoolExecutor
def batch_upload_documents(files, api_key, batch_size=5):
"""
Télécharger des documents par lots pour éviter les limites de débit
Args:
files: Liste des chemins de fichiers à télécharger
api_key: Clé API de Rememberizer
batch_size: Nombre de téléchargements simultanés
"""
headers = {
'X-API-Key': api_key
}
results = []
# Traiter les fichiers par lots
with ThreadPoolExecutor(max_workers=batch_size) as executor:
for i in range(0, len(files), batch_size):
batch = files[i:i+batch_size]
futures = []
# Soumettre le lot de téléchargements
for file_path in batch:
with open(file_path, 'rb') as f:
files = {'file': f}
future = executor.submit(
requests.post,
'https://api.rememberizer.ai/api/v1/documents/upload/',
headers=headers,
files=files
)
futures.append(future)
# Collecter les résultats
for future in futures:
response = future.result()
results.append(response.json())
# Limitation de débit - pause entre les lots
if i + batch_size < len(files):
time.sleep(1)
return results
Opérations de recherche à fort volume¶
Pour les applications nécessitant une recherche à fort volume :
async function batchSearchWithRateLimit(queries, apiKey, options = {}) {
const {
batchSize = 5,
delayBetweenBatches = 1000,
maxRetries = 3,
retryDelay = 2000
} = options;
const results = [];
// Traiter les requêtes par lots
for (let i = 0; i < queries.length; i += batchSize) {
const batch = queries.slice(i, i + batchSize);
const batchPromises = batch.map(query => searchWithRetry(query, apiKey, maxRetries, retryDelay));
// Exécuter le lot
const batchResults = await Promise.all(batchPromises);
results.push(...batchResults);
// Appliquer la limitation de débit entre les lots
if (i + batchSize < queries.length) {
await new Promise(resolve => setTimeout(resolve, delayBetweenBatches));
}
}
return results;
}
async function searchWithRetry(query, apiKey, maxRetries, retryDelay) {
let retries = 0;
while (retries < maxRetries) {
try {
const response = await fetch('https://api.rememberizer.ai/api/v1/search/', {
method: 'POST',
headers: {
'X-API-Key': apiKey,
'Content-Type': 'application/json'
},
body: JSON.stringify({ query })
});
if (response.ok) {
return response.json();
}
// Gérer spécifiquement la limitation de débit
if (response.status === 429) {
const retryAfter = response.headers.get('Retry-After') || retryDelay / 1000;
await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
retries++;
continue;
}
// Autres erreurs
throw new Error(`La recherche a échoué avec le statut : ${response.status}`);
} catch (error) {
retries++;
if (retries >= maxRetries) {
throw error;
}
await new Promise(resolve => setTimeout(resolve, retryDelay));
}
}
}
Gestion des connaissances basée sur l'équipe¶
Rememberizer prend en charge la gestion des connaissances basée sur l'équipe, permettant aux entreprises de :
- Créer des espaces de travail d'équipe : Organiser les connaissances par département ou fonction
- Attribuer des autorisations basées sur les rôles : Contrôler qui peut voir, éditer ou administrer les connaissances
- Partager des connaissances entre les équipes : Configurer l'accès inter-équipes à des bases de connaissances spécifiques
Rôles et autorisations de l'équipe¶
Rememberizer prend en charge les rôles d'équipe suivants :
| Rôle | Capacités |
|---|---|
| Propriétaire | Accès administratif complet, peut gérer les membres de l'équipe et toutes les connaissances |
| Administrateur | Peut gérer les connaissances et configurer les mementos, mais ne peut pas gérer l'équipe elle-même |
| Membre | Peut voir et rechercher des connaissances selon les autorisations des mementos |
Mise en œuvre du partage de connaissances basé sur l'équipe¶
import requests
def create_team_knowledge_base(team_id, name, description, api_key):
"""
Créer une base de connaissances pour une équipe spécifique
"""
headers = {
'X-API-Key': api_key,
'Content-Type': 'application/json'
}
payload = {
'team_id': team_id,
'name': name,
'description': description
}
response = requests.post(
'https://api.rememberizer.ai/api/v1/teams/knowledge/',
headers=headers,
json=payload
)
return response.json()
def grant_team_access(knowledge_id, team_id, permission_level, api_key):
"""
Accorder à une équipe l'accès à une base de connaissances
Args:
knowledge_id: ID de la base de connaissances
team_id: ID de l'équipe à laquelle accorder l'accès
permission_level: 'read', 'write', ou 'admin'
api_key: clé API de Rememberizer
"""
headers = {
'X-API-Key': api_key,
'Content-Type': 'application/json'
}
payload = {
'team_id': team_id,
'knowledge_id': knowledge_id,
'permission': permission_level
}
response = requests.post(
'https://api.rememberizer.ai/api/v1/knowledge/permissions/',
headers=headers,
json=payload
)
return response.json()
Meilleures Pratiques d'Intégration d'Entreprise¶
1. Implémenter une gestion des erreurs robuste¶
Concevez votre intégration pour gérer divers scénarios d'erreurs avec élégance :
async function robustApiCall(endpoint, method, payload, apiKey) {
try {
const response = await fetch(`https://api.rememberizer.ai/api/v1/${endpoint}`, {
method,
headers: {
'X-API-Key': apiKey,
'Content-Type': 'application/json'
},
body: method !== 'GET' ? JSON.stringify(payload) : undefined
});
// Gérer différents types de réponse
if (response.status === 204) {
return { success: true };
}
if (!response.ok) {
const error = await response.json();
throw new Error(error.message || `L'appel API a échoué avec le statut : ${response.status}`);
}
return await response.json();
} catch (error) {
// Enregistrer les détails de l'erreur pour le dépannage
console.error(`L'appel API à ${endpoint} a échoué :`, error);
// Fournir une erreur significative au code appelant
throw new Error(`Échec de ${method} ${endpoint} : ${error.message}`);
}
}
2. Implémenter la mise en cache pour les connaissances fréquemment consultées¶
Réduisez la charge de l'API et améliorez les performances avec une mise en cache appropriée :
Mettre en cache les documents fréquemment consultés pendant 10 minutes¶
@lru_cache(maxsize=100) def get_document_with_cache(document_id, api_key, timestamp=None): """ Obtenir un document avec mise en cache
Args:
document_id: ID du document à récupérer
api_key: Clé API de Rememberizer
timestamp: Horodatage d'invalidation du cache (par défaut : morceaux de 10 min)
"""
# Générer un horodatage qui change toutes les 10 minutes pour l'invalidation du cache
if timestamp is None:
timestamp = int(time.time() / 600)
headers = {
'X-API-Key': api_key
}
response = requests.get(
f'https://api.rememberizer.ai/api/v1/documents/{document_id}/',
headers=headers
)
return response.json()
```
3. Implémenter le traitement asynchrone pour les téléchargements de documents¶
Pour de grands ensembles de documents, implémentez le traitement asynchrone :
javascript
async function uploadLargeDocument(file, apiKey) {
// Étape 1 : Initier le téléchargement
const initResponse = await fetch('https://api.rememberizer.ai/api/v1/documents/upload-async/', {
method: 'POST',
headers: {
'X-API-Key': apiKey,
'Content-Type': 'application/json'
},
body: JSON.stringify({
filename: file.name,
filesize: file.size,
content_type: file.type
})
});
const { upload_id, upload_url } = await initResponse.json();
// Étape 2 : Télécharger le fichier à l'URL fournie
await fetch(upload_url, {
method: 'PUT',
body: file
});
// Étape 3 : Surveiller l'état du traitement
const processingId = await initiateProcessing(upload_id, apiKey);
return monitorProcessingStatus(processingId, apiKey);
}
async function initiateProcessing(uploadId, apiKey) {
const response = await fetch('https://api.rememberizer.ai/api/v1/documents/process/', {
method: 'POST',
headers: {
'X-API-Key': apiKey,
'Content-Type': 'application/json'
},
body: JSON.stringify({
upload_id: uploadId
})
});
const { processing_id } = await response.json();
return processing_id;
}
async function monitorProcessingStatus(processingId, apiKey, interval = 2000) {
while (true) {
const statusResponse = await fetch(`https://api.rememberizer.ai/api/v1/documents/process-status/${processingId}/`, {
headers: {
'X-API-Key': apiKey
}
});
const status = await statusResponse.json();
if (status.status === 'completed') {
return status.document_id;
} else if (status.status === 'failed') {
throw new Error(`Le traitement a échoué : ${status.error}`);
}
// Attendre avant de vérifier à nouveau
await new Promise(resolve => setTimeout(resolve, interval));
}
}
4. Mettre en œuvre une limitation de taux appropriée¶
Respectez les limites de taux de l'API pour garantir un fonctionnement fiable :
import requests
import time
from functools import wraps
class RateLimiter:
def __init__(self, calls_per_second=5):
self.calls_per_second = calls_per_second
self.last_call_time = 0
self.min_interval = 1.0 / calls_per_second
def __call__(self, func):
@wraps(func)
def wrapper(*args, **kwargs):
current_time = time.time()
time_since_last_call = current_time - self.last_call_time
if time_since_last_call < self.min_interval:
sleep_time = self.min_interval - time_since_last_call
time.sleep(sleep_time)
self.last_call_time = time.time()
return func(*args, **kwargs)
return wrapper
# Appliquer une limitation de taux aux appels API
@RateLimiter(calls_per_second=5)
def search_documents(query, api_key):
headers = {
'X-API-Key': api_key,
'Content-Type': 'application/json'
}
payload = {
'query': query
}
response = requests.post(
'https://api.rememberizer.ai/api/v1/search/',
headers=headers,
json=payload
)
return response.json()
Considérations de conformité¶
Résidence des données¶
Pour les organisations ayant des exigences de résidence des données :
- Choisir la région appropriée : Sélectionner les déploiements de Rememberizer dans des régions conformes
- Documenter les flux de données : Cartographier où les connaissances sont stockées et traitées
- Mettre en œuvre le filtrage : Utiliser des mementos pour restreindre l'accès aux données sensibles
Journalisation des audits¶
Implémentez une journalisation des audits complète pour la conformité :
Configurer la journalisation¶
logging.basicConfig( level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s', handlers=[ logging.FileHandler('rememberizer_audit.log'), logging.StreamHandler() ] )
def audit_log_api_call(endpoint, method, user_id, result_status): """ Journaliser les détails de l'appel API à des fins d'audit """ log_entry = { 'timestamp': time.time(), 'endpoint': endpoint, 'method': method, 'user_id': user_id, 'status': result_status }
logging.info(f"APPEL API: {json.dumps(log_entry)}")
def search_with_audit(query, api_key, user_id): endpoint = 'search' method = 'POST'
try:
headers = {
'X-API-Key': api_key,
'Content-Type': 'application/json'
}
payload = {
'query': query
}
response = requests.post(
'https://api.rememberizer.ai/api/v1/search/',
headers=headers,
json=payload
)
status = 'success' if response.ok else 'error'
audit_log_api_call(endpoint, method, user_id, status)
return response.json()
except Exception as e:
audit_log_api_call(endpoint, method, user_id, 'exception')
raise
```
Prochaines étapes¶
Pour mettre en œuvre des intégrations d'entreprise avec Rememberizer :
- Concevez votre architecture de connaissances : Cartographiez les domaines de connaissances et les modèles d'accès
- Mettez en place des structures d'équipe basées sur les rôles : Créez des équipes et attribuez les autorisations appropriées
- Implémentez des flux d'authentification : Choisissez et mettez en œuvre les méthodes d'authentification qui répondent à vos exigences
- Concevez des flux de travail évolutifs : Implémentez le traitement par lots pour l'ingestion de documents
- Établissez des politiques de surveillance et d'audit : Mettez en place la journalisation et la surveillance pour la conformité et les opérations
Ressources Associées¶
- Accès au Filtre des Mementos - Contrôlez quelles sources de données sont disponibles pour les intégrations
- Documentation de l'API - Référence complète de l'API pour tous les points de terminaison
- Intégration LangChain - Intégration programmatique avec le cadre LangChain
- Créer un Rememberizer GPT - Intégration avec la plateforme GPT d'OpenAI
- Magasins de Vecteurs - Détails techniques de l'implémentation de la base de données vectorielle de Rememberizer
Pour une assistance supplémentaire concernant les intégrations d'entreprise, contactez l'équipe de Rememberizer via le portail de Support.