Integration Guide

// Helper function for AIPersona API calls
async function callAIPersona(procedure, data) {
  const response = await fetch(`https://aipersona.dsethiopia.org/api/trpc/${procedure}`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': process.env.AIPERSONA_API_KEY,
      'X-Organization-ID': process.env.AIPERSONA_ORG_ID,
    },
    body: JSON.stringify({ json: data })
  });
  
  const result = await response.json();
  if (result.error) throw new Error(result.error.message);
  return result.result.data;
}

// Create a persona
const persona = await callAIPersona('persona.create', {
  name: 'Customer Support Bot',
  description: 'Handles customer inquiries',
  systemPrompt: 'You are a helpful customer support agent...',
  model: 'gpt-4o',
  llmProvider: 'OPENAI',
  temperature: 0.7,
  maxTokens: 2000
});

// Create a chat session
const session = await callAIPersona('chat.createSession', {
  personaId: persona.id,
  title: 'Customer Inquiry',
  platform: 'API'
});

// Send a message
const message = await callAIPersona('chat.sendMessage', {
  chatSessionId: session.id,
  content: 'Hello! I need help with my order.',
  role: 'USER'
});

console.log('AI Response:', message.content);

import os
import requests

class AIPersonaClient:
    def __init__(self, api_key=None, org_id=None, base_url=None):
        self.api_key = api_key or os.environ.get('AIPERSONA_API_KEY')
        self.org_id = org_id or os.environ.get('AIPERSONA_ORG_ID')
        self.base_url = base_url or 'https://aipersona.dsethiopia.org/api/trpc'
        
    def _call(self, procedure, data):
        response = requests.post(
            f'{self.base_url}/{procedure}',
            headers={
                'Content-Type': 'application/json',
                'X-API-Key': self.api_key,
                'X-Organization-ID': self.org_id,
            },
            json={'json': data}
        )
        result = response.json()
        if 'error' in result:
            raise Exception(result['error']['message'])
        return result['result']['data']
    
    def create_persona(self, **kwargs):
        return self._call('persona.create', kwargs)
    
    def create_session(self, persona_id, title='', platform='API'):
        return self._call('chat.createSession', {
            'personaId': persona_id,
            'title': title,
            'platform': platform
        })
    
    def send_message(self, session_id, content, role='USER'):
        return self._call('chat.sendMessage', {
            'chatSessionId': session_id,
            'content': content,
            'role': role
        })

# Usage
client = AIPersonaClient()

persona = client.create_persona(
    name='Support Bot',
    description='Handles support inquiries',
    systemPrompt='You are a helpful support agent...',
    model='gpt-4o',
    llmProvider='OPENAI'
)

session = client.create_session(persona['id'], 'Support Request')
response = client.send_message(session['id'], 'Hello, I need help!')
print('AI Response:', response['content'])

// lib/trpc.ts
import { createTRPCProxyClient, httpBatchLink } from '@trpc/client';
import superjson from 'superjson';

// Import the AppRouter type from AIPersona if available,
// or use 'any' for untyped access
type AppRouter = any;

export const trpc = createTRPCProxyClient<AppRouter>({
  transformer: superjson,
  links: [
    httpBatchLink({
      url: 'https://your-aipersona-domain.com/api/trpc',
      headers() {
        return {
          'X-API-Key': process.env.NEXT_PUBLIC_AIPERSONA_API_KEY!,
          'X-Organization-ID': process.env.NEXT_PUBLIC_AIPERSONA_ORG_ID!,
        };
      },
    }),
  ],
});

// In your component or API route
const personas = await trpc.persona.list.query();

const newPersona = await trpc.persona.create.mutate({
  name: 'My Assistant',
  description: 'A helpful assistant',
  systemPrompt: 'You are helpful...',
  model: 'gpt-4o',
  llmProvider: 'OPENAI'
});

const session = await trpc.chat.createSession.mutate({
  personaId: newPersona.id,
  title: 'New Chat'
});

const response = await trpc.chat.sendMessage.mutate({
  chatSessionId: session.id,
  content: 'Hello!',
  role: 'USER'
});