Start Voice Agent Call
{callResult && (
{callResult.message}
{callResult.success && (
Call ID: {callResult.callId}
)}
)}
);
};
export default FamuloreCallComponent;
```
### Backend API Proxy (Express.js)
```javascript theme={null}
// Backend proxy for secure API calls
const express = require('express');
const router = express.Router();
// Fetch assistants
router.get('/assistants', async (req, res) => {
try {
const response = await fetch('https://app.famulor.de/api/user/assistants', {
headers: {
'Authorization': `Bearer ${process.env.FAMULOR_API_KEY}`,
'Content-Type': 'application/json'
}
});
if (!response.ok) {
throw new Error(`API Error: ${response.status}`);
}
const assistants = await response.json();
res.json(assistants);
} catch (error) {
res.status(500).json({ error: error.message });
}
});
// Make a call
router.post('/make-call', async (req, res) => {
try {
const { phone_number, assistant_id, variables } = req.body;
// Input validation
if (!phone_number || !assistant_id) {
return res.status(400).json({
error: 'phone_number and assistant_id are required'
});
}
const response = await fetch('https://app.famulor.de/api/user/make_call', {
method: 'POST',
headers: {
'Authorization': `Bearer ${process.env.FAMULOR_API_KEY}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
phone_number,
assistant_id,
variables: variables || {}
})
});
const result = await response.json();
if (!response.ok) {
return res.status(response.status).json(result);
}
res.json(result);
} catch (error) {
res.status(500).json({ error: error.message });
}
});
module.exports = router;
```
## Error Handling and Retry Logic
```javascript theme={null}
class FamuloreApiClient {
constructor(apiKey) {
this.apiKey = apiKey;
this.baseUrl = 'https://app.famulor.de/api';
this.maxRetries = 3;
this.retryDelay = 1000; // 1 second
}
async makeRequest(endpoint, options = {}) {
const url = `${this.baseUrl}${endpoint}`;
const defaultOptions = {
headers: {
'Authorization': `Bearer ${this.apiKey}`,
'Content-Type': 'application/json',
...options.headers
}
};
const requestOptions = { ...defaultOptions, ...options };
for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
try {
const response = await fetch(url, requestOptions);
// Handle rate limiting
if (response.status === 429) {
const retryAfter = response.headers.get('Retry-After') || this.retryDelay / 1000;
console.log(`Rate limit reached, waiting ${retryAfter} seconds...`);
await this.sleep(retryAfter * 1000);
continue;
}
const data = await response.json();
if (!response.ok) {
throw new Error(`HTTP ${response.status}: ${data.message || 'Unknown error'}`);
}
return data;
} catch (error) {
console.log(`Attempt ${attempt}/${this.maxRetries} failed:`, error.message);
if (attempt === this.maxRetries) {
throw error;
}
// Exponential backoff
const delay = this.retryDelay * Math.pow(2, attempt - 1);
await this.sleep(delay);
}
}
}
sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
// API methods
async getAssistants() {
return this.makeRequest('/user/assistants');
}
async makeCall(phoneNumber, assistantId, variables = {}) {
return this.makeRequest('/user/make_call', {
method: 'POST',
body: JSON.stringify({
phone_number: phoneNumber,
assistant_id: assistantId,
variables
})
});
}
async getCalls(limit = 50) {
return this.makeRequest(`/user/calls?limit=${limit}`);
}
}
// Usage with error handling
const client = new FamuloreApiClient(process.env.FAMULOR_API_KEY);
async function robustCall() {
try {
const result = await client.makeCall('+4915123456789', 123, {
customer_name: 'Test Kunde'
});
console.log('Call successful:', result.call_id);
} catch (error) {
console.error('Final error after all attempts:', error.message);
// Notification, logging, etc. could happen here
}
}
```
## Batch Processing
```python theme={null}
import asyncio
import aiohttp
from typing import List, Dict
import csv
class BatchCallProcessor:
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = 'https://app.famulor.de/api'
self.session = None
async def __aenter__(self):
self.session = aiohttp.ClientSession(
headers={'Authorization': f'Bearer {self.api_key}'}
)
return self
async def __aexit__(self, exc_type, exc_val, exc_tb):
if self.session:
await self.session.close()
async def make_single_call(self, phone_number: str, assistant_id: int,
variables: Dict = None, semaphore=None):
"""Make a single call asynchronously"""
async with semaphore: # Rate limiting
try:
payload = {
'phone_number': phone_number,
'assistant_id': assistant_id,
'variables': variables or {}
}
async with self.session.post(
f'{self.base_url}/user/make_call',
json=payload
) as response:
result = await response.json()
if response.status == 200:
return {
'status': 'success',
'phone_number': phone_number,
'call_id': result['call_id'],
'message': result['message']
}
else:
return {
'status': 'error',
'phone_number': phone_number,
'error': result.get('message', 'Unknown error')
}
except Exception as e:
return {
'status': 'error',
'phone_number': phone_number,
'error': str(e)
}
async def process_batch_calls(self, call_list: List[Dict],
concurrent_limit: int = 5):
"""Process a batch of calls"""
semaphore = asyncio.Semaphore(concurrent_limit)
tasks = []
for call_data in call_list:
task = self.make_single_call(
phone_number=call_data['phone_number'],
assistant_id=call_data['assistant_id'],
variables=call_data.get('variables', {}),
semaphore=semaphore
)
tasks.append(task)
results = await asyncio.gather(*tasks, return_exceptions=True)
return results
@classmethod
def from_csv(cls, csv_file: str, assistant_id: int, api_key: str):
"""Convert CSV file into call list"""
call_list = []
with open(csv_file, 'r', encoding='utf-8') as file:
reader = csv.DictReader(file)
for row in reader:
call_data = {
'phone_number': row['phone_number'],
'assistant_id': assistant_id,
'variables': {
'customer_name': row.get('name', ''),
'email': row.get('email', ''),
'company': row.get('company', '')
}
}
call_list.append(call_data)
return call_list
# Example usage
async def main():
api_key = os.getenv('FAMULOR_API_KEY')
# Load CSV data
call_list = BatchCallProcessor.from_csv('leads.csv', assistant_id=123, api_key=api_key)
# Batch processing
async with BatchCallProcessor(api_key) as processor:
results = await processor.process_batch_calls(call_list, concurrent_limit=3)
# Evaluate results
success_count = sum(1 for r in results if r['status'] == 'success')
error_count = len(results) - success_count
print(f"Processing complete:")
print(f"✅ Successful: {success_count}")
print(f"❌ Errors: {error_count}")
# Error details
for result in results:
if result['status'] == 'error':
print(f"Error for {result['phone_number']}: {result['error']}")
# Run
if __name__ == "__main__":
asyncio.run(main())
```
## Next Steps