Abena AI SDK Documentation

pip install abenasdk

from abenasdk import AbenasClient

# Initialize client
client = AbenasClient(api_key="your-api-key")

# Speech Recognition
result = client.asr.transcribe("audio.wav", language="LANGUAGE_PLACEHOLDER")
print(f"📝 Transcription: {result['text']}")

# Text-to-Speech
client.tts.synthesize("Hello world!", language_code="TTS_LANGUAGE_PLACEHOLDER", output_file="speech.wav")
print("🔊 Speech generated!")

# Translation
result = client.translator.translate("Hello", source_lang="TRANSLATION_SOURCE_PLACEHOLDER", target_lang="TRANSLATION_TARGET_PLACEHOLDER")
print(f"🌍 Translation: {result['translation']}")

npm install abenasdk

const { AbenasClient } = require('abenasdk');

// Initialize client
const client = new AbenasClient('your-api-key');

async function example() {
  // Speech Recognition
  const asr = await client.asr.transcribe('audio.wav', 'LANGUAGE_PLACEHOLDER');
  console.log('📝 Transcription:', asr.text);

  // Text-to-Speech
  await client.tts.synthesize('Hello world!', 'TTS_LANGUAGE_PLACEHOLDER', 'speech.wav');
  console.log('🔊 Speech generated!');

  // Translation
  const translation = await client.translator.translate('Hello', 'TRANSLATION_SOURCE_PLACEHOLDER', 'TRANSLATION_TARGET_PLACEHOLDER');
  console.log('🌍 Translation:', translation.translation);
}

example().catch(console.error);

const { ValidationError, APIError, FileError } = require('abenasdk');

try {
  const result = await client.asr.transcribe('audio.wav');
} catch (error) {
  if (error instanceof ValidationError) {
    console.error('Invalid input:', error.message);
  } else if (error instanceof FileError) {
    console.error('File error:', error.message);
  } else {
    console.error('API error:', error.message);
  }
}

go get github.com/abena-ai-team/abenasdk-go

package main

import (
    "fmt"
    "log"
    
    "github.com/abena-ai-team/abenasdk-go/pkg/abenasdk"
)

func main() {
    // Initialize client
    client, err := abenasdk.NewClient("your-api-key")
    if err != nil {
        log.Fatal(err)
    }

    // Speech Recognition
    asr, err := client.ASR.Transcribe("audio.wav", "en")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("📝 Transcription: %s\n", asr.Text)

    // Text-to-Speech
    _, err = client.TTS.Synthesize("Hello world!", "TTS_LANGUAGE_PLACEHOLDER", "speech.wav")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("🔊 Speech generated!")

    // Translation
    translation, err := client.Translator.Translate("Hello", "TRANSLATION_SOURCE_PLACEHOLDER", "TRANSLATION_TARGET_PLACEHOLDER")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("🌍 Translation: %s\n", translation.Translation)
}

result, err := client.ASR.Transcribe("audio.wav", "en")
if err != nil {
    switch e := err.(type) {
    case *abenasdk.ValidationError:
        fmt.Printf("Invalid input: %v\n", e)
    case *abenasdk.APIError:
        fmt.Printf("API error (status %d): %v\n", e.StatusCode, e)
    case *abenasdk.FileError:
        fmt.Printf("File error: %v\n", e)
    default:
        fmt.Printf("Unknown error: %v\n", e)
    }
    return
}

curl -X POST https://abena.mobobi.com/playground/api/v1/asr/transcribe/ \
  -H "Authorization: Bearer your-api-key" \
  -F "audio_file=@audio.wav" \
  -F "language=en"

curl -X POST https://abena.mobobi.com/playground/api/v1/tts/synthesize/ \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello world!", "language_code": "TTS_LANGUAGE_PLACEHOLDER"}' \
  --output speech.wav

curl -X POST https://abena.mobobi.com/playground/api/v1/translate/translate/ \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello world!", "source_language": "TRANSLATION_SOURCE_PLACEHOLDER", "target_language": "TRANSLATION_TARGET_PLACEHOLDER"}'

import { AbenaSDK, useAbena } from '@abenasdk/react-native';

const App = () => {
  const { isReady } = useAbena({ apiKey: 'YOUR_API_KEY' });
  if (!isReady) return ;
  return Abena SDK is Ready!;
};

import AbenaSDK
import SwiftUI

@main
struct YourApp: App {
    init() {
        AbenaSDK.configure(withAPIKey: "YOUR_API_KEY")
    }
    var body: some Scene { WindowGroup { ContentView() } }
}

import com.abena.sdk.AbenaSDK
import com.abena.sdk.AbenaConfig

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        val config = AbenaConfig.Builder("YOUR_API_KEY").build()
        AbenaSDK.initialize(this, config)
    }
}