Integration Guide
Complete guide to integrating DeepV-ADK into your application.Overview
This guide walks you through integrating DeepV-ADK into your existing application workflow.Integration Patterns
Synchronous Integration
For real-time decision making: ``typescript
import { DeepVClient } from '@deepv/adk-sdk';
async function processApplication(applicantData: ApplicantData) {
const client = new DeepVClient({ apiKey: process.env.DEEPV_API_KEY });
try {
const result = await client.analyze({
applicantData,
options: {
timeout: 5000,
includeReasons: true
}
});
if (result.decision === 'APPROVE') {
await approveApplication(applicantData.id);
} else {
await rejectApplication(applicantData.id, result.reasons);
}
} catch (error) {
// Handle error
await flagForManualReview(applicantData.id);
}
}
`
Asynchronous Integration
For batch processing:
`typescript
async function processBatch(applicants: ApplicantData[]) {
const client = new DeepVClient({ apiKey: process.env.DEEPV_API_KEY });
const batchResult = await client.analyzeBatch({
applicants: applicants.map(a => ({ id: a.id, data: a }))
});
// Poll for results
const results = await client.waitForBatch(batchResult.batchId);
for (const result of results) {
await updateApplicantStatus(result.id, result.decision);
}
}
`
Webhook Integration
For event-driven architecture:
`typescript
// Setup webhook
await client.createWebhook({
url: 'https://your-app.com/webhooks/deepv',
events: ['analysis.completed']
});
// Webhook handler
app.post('/webhooks/deepv', async (req, res) => {
const event = req.body;
if (event.event === 'analysis.completed') {
await updateApplicantStatus(
event.data.applicant.id,
event.data.decision
);
}
res.status(200).send('OK');
});
`
Common Integration Scenarios
Loan Application Workflow
`typescript
class LoanApplicationService {
private deepv: DeepVClient;
constructor() {
this.deepv = new DeepVClient({ apiKey: process.env.DEEPV_API_KEY });
}
async processApplication(application: LoanApplication) {
// Step 1: Collect applicant data
const applicantData = this.formatApplicantData(application);
// Step 2: Run DeepV analysis
const analysis = await this.deepv.analyze({
applicantData,
options: {
includeReasons: true,
riscScoring: true
}
});
// Step 3: Apply business rules
const decision = this.applyBusinessRules(analysis);
// Step 4: Update application status
await this.updateApplication(application.id, {
status: decision.status,
riskScore: analysis.riskScore,
reasons: analysis.reasons
});
return decision;
}
private applyBusinessRules(analysis: AnalysisResult) {
if (analysis.riskScore >= 700 && analysis.decision === 'APPROVE') {
return { status: 'APPROVED', interestRate: 5.5 };
} else if (analysis.riskScore >= 600) {
return { status: 'CONDITIONAL', interestRate: 7.5 };
} else {
return { status: 'DECLINED', reason: analysis.reasons[0] };
}
}
}
`
User Registration Flow
`typescript
async function registerUser(userData: UserData) {
// Step 1: Basic validation
validateUserData(userData);
// Step 2: Risk assessment
const riskAssessment = await deepv.analyze({
applicantData: {
firstName: userData.firstName,
lastName: userData.lastName,
email: userData.email,
phone: userData.phone
}
});
// Step 3: Determine account tier
const accountTier = determineAccountTier(riskAssessment.riskScore);
// Step 4: Create user account
const user = await createUser({
...userData,
accountTier,
riskScore: riskAssessment.riskScore
});
return user;
}
`
Error Handling
Comprehensive Error Handling
`typescript
async function analyzeWithRetry(applicantData: ApplicantData) {
const maxRetries = 3;
let attempt = 0;
while (attempt < maxRetries) {
try {
const result = await client.analyze({ applicantData });
return result;
} catch (error) {
attempt++;
if (error.code === 'RATE_LIMIT_EXCEEDED') {
// Wait before retry
await delay(Math.pow(2, attempt) * 1000);
continue;
}
if (error.code === 'INVALID_INPUT') {
// Don't retry validation errors
throw error;
}
if (attempt >= maxRetries) {
// Fallback to manual review
await flagForManualReview(applicantData);
throw error;
}
}
}
}
`
Performance Optimization
Caching Results
`typescript
import { LRUCache } from 'lru-cache';
const cache = new LRUCache({
max: 1000,
ttl: 1000 60 60 // 1 hour
});
async function analyzeWithCache(applicantData: ApplicantData) {
const cacheKey = generateCacheKey(applicantData);
const cached = cache.get(cacheKey);
if (cached) {
return cached;
}
const result = await client.analyze({ applicantData });
cache.set(cacheKey, result);
return result;
}
`
Batch Processing
Process multiple applicants efficiently:
`typescript
async function processBatchOptimized(applicants: ApplicantData[]) {
// Split into chunks of 100
const chunks = chunk(applicants, 100);
for (const chunk of chunks) {
const batch = await client.analyzeBatch({
applicants: chunk.map(a => ({ id: a.id, data: a }))
});
// Process results asynchronously via webhook
await client.createWebhook({
url: https://your-app.com/batch/${batch.batchId},
events: ['batch.completed']
});
}
}
`
Testing
Mock Client for Testing
`typescript
class MockDeepVClient {
async analyze(params: AnalyzeParams): Promise {
return {
success: true,
riskScore: 750,
decision: 'APPROVE',
reasons: ['Test reason']
};
}
}
// In tests
const client = process.env.NODE_ENV === 'test'
? new MockDeepVClient()
: new DeepVClient({ apiKey: process.env.DEEPV_API_KEY });
``
Next Steps
Found an issue? Help us improve this page.