Video Tutorial 1: Getting Started with Oshun AI Integrations

Duration: 15-20 minutes Format: Screen recording with voiceover Target Audience: Developers new to Oshun AI integrations

Video Script#

Opening (0:00 - 0:30)#

[Screen: Oshun logo and title card]

Welcome to the Oshun AI Integrations tutorial series. I'm [name], and in this video, we'll learn how to set up and use the Oshun AI providers to synthesize speech, generate images, and discover models.

[Screen: Overview slide showing what we'll cover]

By the end of this tutorial, you'll be able to:

• Initialize AI providers
• Generate speech from text
• Create AI-generated images
• Search for models on Civitai

Part 1: Setup (0:30 - 2:30)#

[Screen: Terminal]

Let's start by setting up our development environment. First, make sure you have Node.js 18 or later installed.

node --version
# v20.x.x

Next, we'll set up our API keys. You'll need keys from ElevenLabs, RunComfy, and optionally Civitai.

[Screen: Show environment variables]

export ELEVENLABS_API_KEY=your_key_here
export RUNCOMFY_API_KEY=your_key_here
export CIVITAI_API_KEY=your_key_here

I recommend storing these in a .env file for convenience. Just make sure not to commit it to version control.

[Screen: Create new TypeScript file]

Let's create a new file called ai-demo.ts. First, we'll import the providers we need.

import {
  ElevenLabsProvider,
  RunComfyProvider,
  CivitaiProvider,
} from '@oshun/ai-providers';

Part 2: Text-to-Speech (2:30 - 6:00)#

[Screen: Code editor]

Let's start with text-to-speech using ElevenLabs. First, we create a provider instance.

const elevenlabs = new ElevenLabsProvider({
  apiKey: process.env.ELEVENLABS_API_KEY!,
});

The exclamation mark tells TypeScript we know this value exists. In production, you'd want to add proper validation.

[Screen: Add synthesis code]

Now let's synthesize some text. We call the synthesize method with our text and a voice ID.

const audio = await elevenlabs.synthesize({
  text: 'Hello! Welcome to the Oshun AI tutorial.',
  voiceId: 'EXAVITQu4vr4xnSDxMaL', // Sarah voice
});

console.log(`Generated ${audio.length} bytes of audio`);

[Screen: Run the code]

Let's run this and see what happens.

npx ts-node ai-demo.ts
# Generated 45632 bytes of audio

Excellent! We got audio data back. Let's save it to a file so we can hear it.

import { writeFileSync } from 'fs';
writeFileSync('hello.mp3', audio);

[Screen: Play the audio file]

And there we have it - our first AI-generated speech!

[Screen: Show voice settings]

You can customize the voice by adjusting settings like stability and similarity boost.

const audio = await elevenlabs.synthesize({
  text: 'This is a customized voice.',
  voiceId: 'EXAVITQu4vr4xnSDxMaL',
  voiceSettings: {
    stability: 0.3,        // More expressive
    similarity_boost: 0.9, // Close to original
  },
});

Lower stability makes the voice more expressive but less predictable. Higher similarity boost keeps it closer to the original voice sample.

Part 3: Image Generation (6:00 - 10:00)#

[Screen: New code section]

Now let's generate some images using ComfyUI through RunComfy. We start by creating a provider.

const runcomfy = new RunComfyProvider({
  apiKey: process.env.RUNCOMFY_API_KEY!,
  maxConcurrentJobs: 5,
});

The maxConcurrentJobs setting limits how many images we generate at once.

[Screen: Submit workflow]

To generate an image, we submit a workflow with our prompt.

const job = await runcomfy.executeWorkflow({
  workflowId: 'txt2img-sdxl-v1',
  inputs: {
    prompt: 'A majestic dragon flying over mountains at sunset, highly detailed',
    negative_prompt: 'blurry, low quality, watermark',
    width: 1024,
    height: 1024,
    steps: 25,
  },
});

console.log(`Job ID: ${job.id}`);
console.log(`Status: ${job.status}`);

[Screen: Run and show output]

npx ts-node ai-demo.ts
# Job ID: job_abc123
# Status: queued

The job is now queued. Image generation takes time, so we need to wait for it.

const completed = await runcomfy.waitForCompletion(job.id, {
  timeoutMs: 300000, // 5 minutes
  onStatusChange: (status) => {
    console.log(`Status: ${status}`);
  },
});

if (completed.status === 'completed') {
  console.log('Image generated!');
  console.log(`URL: ${completed.outputs[0].url}`);
}

[Screen: Show generated image]

And here's our generated dragon! The AI has created a stunning image based on our text description.

Part 4: Model Discovery (10:00 - 13:00)#

[Screen: New code section]

Finally, let's explore Civitai to discover AI models. This is optional but very useful for finding new models.

const civitai = new CivitaiProvider({
  apiKey: process.env.CIVITAI_API_KEY, // Optional
  enableCache: true,
});

[Screen: Search models]

We can search for models with various filters.

const results = await civitai.searchModels({
  query: 'anime',
  types: ['LORA'],
  baseModels: ['SDXL 1.0'],
  sort: 'Highest Rated',
  limit: 5,
});

for (const model of results.items) {
  console.log(`${model.name} - ${model.stats.downloadCount} downloads`);
}

[Screen: Run and show output]

npx ts-node ai-demo.ts
# Anime SDXL v2 - 125,432 downloads
# Character Style Pro - 98,234 downloads
# ...

These are the top-rated anime LoRA models for SDXL. You can use these with your image generation to add specific styles.

[Screen: Get model details]

Let's get more details about a specific model.

const model = await civitai.getModel(12345);
console.log(`Name: ${model.name}`);
console.log(`Creator: ${model.creator.username}`);
console.log(`Tags: ${model.tags.join(', ')}`);

Part 5: Error Handling (13:00 - 15:00)#

[Screen: Error handling code]

In production, you'll want to handle errors gracefully. Let's wrap our code in try-catch blocks.

try {
  const audio = await elevenlabs.synthesize({
    text: 'Test',
    voiceId: 'invalid-voice',
  });
} catch (error) {
  if (error instanceof Error) {
    console.error(`Error: ${error.message}`);

    const apiError = error as any;
    if (apiError.code === 'VOICE_NOT_FOUND') {
      console.log('That voice does not exist. Try listing available voices.');
    }
  }
}

[Screen: Health check]

You can also check if providers are healthy before making requests.

const healthy = await elevenlabs.healthCheck();
console.log(`ElevenLabs healthy: ${healthy}`);

Closing (15:00 - 16:00)#

[Screen: Summary slide]

That's it for this introduction! We've learned how to:

• Set up AI providers with proper configuration
• Generate speech from text using ElevenLabs
• Create images using ComfyUI workflows
• Discover models on Civitai
• Handle errors gracefully

[Screen: Resources slide]

For more advanced topics, check out:

• The code examples in the training folder
• The hands-on exercises
• The next video on production patterns

Thanks for watching! If this was helpful, please like and subscribe, and I'll see you in the next video.

[Screen: End card with links]

B-Roll Suggestions#

• Terminal commands being typed
• Code highlighting as it's explained
• Generated audio waveform
• Generated images appearing
• Civitai model browsing
• Error messages being caught

Notes for Recording#

1. Use a clear, moderate speaking pace
2. Pause briefly when switching between code sections
3. Highlight important code with cursor movements
4. Show actual output, not just expected output
5. Keep energy consistent throughout