DEV Community: Ifeanyi Idiaye

SynthScope: Search, Visualize, Listen to Information

Ifeanyi Idiaye — Wed, 18 Jun 2025 19:26:33 +0000

In this post, I will introduce you to SynthScope, one of my latest Google Gemini-based projects that enables a user to search the web and return search results as text, image, and audio simultaneously.

This post will give a high-level overview of the application. It will not discuss code implementation; just how to use the application for your daily information needs. Links to the application and codebase on GitHub are shared in this post.

What is SynthScope?
SynthScope is an LLM-powered tool that can be used to retrieve information from the web. Web search results powered by Google Search are returned as text and audio, and also converted into an image generation prompt, which is used to imagine the search result. You can also set SynthScope to translate the generated text and audio into any of 15 supported languages besides English, including Tamil, Thai, Japanese, and Arabic.

Features of SynthScope

Text generation: Displays the search result in the preferred language text.
Image generation: Displays the search result in the preferred image style out of 11 different styles.
Audio generation: Speech capability reads out the search result.
Language translation: Select the preferred language for the text and audio output.

How to Use SynthScope
Using SynthScope is very easy. Simply type in your search query, select the image style in which you want SynthScope to imagine the search result, select the preferred language from the language dropdown menu, and select the preferred voice of the reader from the voice dropdown menu.

Here is a diagram summary of how to use SynthScope:

With SynthScope, you can search for current information on the web and have it read out to you in your preferred language instead of scrolling to read text.

What Technologies Built SynthScope?
Here are the technologies that were used to build SynthScope:

Python for writing the application logic.
Google Gemini family of models for text generation, image generation, and text-to-speech (TTS).
Gradio for frontend development.
CSS for styling the frontend of the Gradio application.
Hugging Face for deploying the application.

How to Access SynthScope
SynthScope is currently deployed on Hugging Face as a space. You can access it here.

Also, SynthScope is an open-source project, and that means that you can take a look at the code behind the application and even make contributions. You can access the code on GitHub.

I would appreciate your supporting the project with a Hugging Face like and a GitHub star, if possible :).

Limitation of Using SynthScope
The principal limitation of using SynthScope is that it is subject to the rate limits imposed on Google's Gemini models' free tier API. Here are the rate limits:

Text generation: Limited to 1500 requests per day
Image generation: Limited to 100 requests per day
Audio generation: Limited to 15 requests per day

Therefore, you may try to use SynthScope at a time when the daily quota for any of the above functionalities has been exhausted.

Conclusion
SynthScope is a creative way to search the internet for information. It is designed to be user-friendly and language dynamic, enabling users to read, visualize, and listen to information.

Build A Real-Time Voice Assistant with Mistral AI and FastRTC

Ifeanyi Idiaye — Sun, 09 Mar 2025 18:29:09 +0000

In this post, I will show you how to build a real-time voice assistant with Mistral AI and FastRTC.

Mistral AI is one of the leading LLM providers out there, and they have made their LLM API easily accessible to developers.

FastRTC, on the other hand, is a real-time communication library for Python that enables you to quickly turn any Python function into real-time audio and video stream over WebRTC or WebSockets.

Building A Real-time Voice Assistant
First, let's install the required libraries by running the code below in your terminal

pip install mistalai fastrtc

Next, set an environment variable and import the libraries. Create a .env file in your project and save your Mistral API key there

MISTRAL_API_KEY = "<your-api-key>"

Import the libraries

from mistralai import Mistral
from fastrtc import (ReplyOnPause, Stream, get_stt_model, get_tts_model)
from dotenv import load_dotenv
import os

load_dotenv()

To get your Mistral API key, you will need to create an account on their website.

In the above, we have imported Mistral and the specific methods that we need from FastRTC namely ReplyOnPause(), Stream(), get_stt_model(), and get_tts_model()

ReplyOnPause(): This method takes a Python audio function. It monitors the audio, and when it detects a pause, it takes it as a cue to give a reply.

Stream(): This method streams the audio reply.

get_stt_model(): This is used to access the speech-to-text model that is used to convert audio to text.

get_tts_model(): This is used to access the text-to-speech model that is used to convert text back into audio.

Now, let's activate the Mistral client with our API key stored in the .env file

api_key = os.environ["MISTRAL_API_KEY"]
model = "mistral-large-latest"

client = Mistral(api_key=api_key)

Here we are using Mistral large model. However, you can try out other Mistral models too.

Also, in actuality, you can plug any LLM into FastRTC and get real-time voice responses.

We will now build the audio function that will take a prompt and return a response

stt_model = get_stt_model()
tts_model = get_tts_model()


def echo(audio):
    prompt = stt_model.stt(audio)
    chat_response = client.chat.complete(
    model = model,
    messages = [
        {
            "role": "user",
            "content": f"{prompt}"
        },
      ]
    )

    for audio_chunk in tts_model.stream_tts_sync(chat_response.choices[0].message.content):
        yield audio_chunk

Above, we wrote a function called echo, and the function takes an audio input, then passes that to the speech-to-text method, which is converted to a user prompt and given to the LLM. The response from the LLM is then passed to a text-to-speech method and is streamed synchronously.

Finally, we will run the application

stream = Stream(ReplyOnPause(echo), modality="audio", mode="send-receive")
stream.ui.launch()

This will launch the UI below at the URL: http://127.0.0.1:7860/

Now, you can activate the microphone and say something to your assistant who will give you a reply immediately.

Change Voice
If you do not like the default voice, you can change that by passing an instance of KokoroTTSOptions() to the text-to-speech method.

First import KokoroTTSOptions() from FastRTC by adding it to the import tuple

from fastrtc import (ReplyOnPause, Stream, get_stt_model, get_tts_model, KokoroTTSOptions)

Next, define the options

tts_model = get_tts_model(model="kokoro")

options = KokoroTTSOptions(
    voice="af_bella",
    speed=1.0,
    lang="en-us"
)

Then pass the options to the text-to-speech method in your audio function

for audio_chunk in tts_model.stream_tts_sync(chat_response.choices[0].message.content, options = options)
        yield audio_chunk

For more voice options, you can check out KokoroTTS documentation.

Complete Project Code
Here is the complete code that we have used to create the real-time voice assistant

import os
from fastrtc import (ReplyOnPause, Stream, get_stt_model, get_tts_model, KokoroTTSOptions)
from dotenv import load_dotenv
from mistralai import Mistral

load_dotenv()

api_key = os.environ["MISTRAL_API_KEY"]
model = "mistral-large-latest"

client = Mistral(api_key=api_key)

options = KokoroTTSOptions(
    voice="af_bella",
    speed=1.0,
    lang="en-us"
)

stt_model = get_stt_model()
tts_model = get_tts_model(model="kokoro")

def echo(audio):
    prompt = stt_model.stt(audio)
    chat_response = client.chat.complete(
    model = model,
    messages = [

        {
            "role": "user",
            "content": f"{prompt}"
        },
      ]
    )

    for audio_chunk in tts_model.stream_tts_sync(chat_response.choices[0].message.content, options=options):
        yield audio_chunk

stream = Stream(ReplyOnPause(echo), modality="audio", mode="send-receive")
stream.ui.launch()

Now, instead of typing a prompt, you can give voice commands to an LLM and have it speak its response, just like a natural human conversation.

I hope you found this post useful. If you did, please share it with others it might benefit too. Thanks for reading!

Run DeepSeek R-1 Thinking Model in Kaggle Notebook Using Ollama

Ifeanyi Idiaye — Tue, 04 Feb 2025 16:41:15 +0000

With DeepSeek being the rave of the moment right now in the world of AI, it is no wonder that every developer wants to explore the power and capabilities of their models. However, a limiting factor remains the fact that powerful large language models like DeepSeek's models require heavy compute power (GPUs) in order to run them locally.

Thankfully, cloud providers like Kaggle offer free GPUs at a limited runtime per week to developers so that they can run or train compute-intensive open-source models.

Now let's see the simple steps to run DeepSeek R-1 reasoning model in a Kaggle notebook with the aid of Ollama.

STEP 1: Create a new Kaggle notebook

STEP 2: Go to Setting > Accelerator and select GPU T4 x2. This is a powerful-enough machine.

STEP 3: Install Ollama in your notebook

!curl -fsSL https://ollama.com/install.sh | sh

This downloads and executes the installation script for Ollama.

STEP 4: Install Ollama Python SDK

!pip install ollama

STEP 5: Start Ollama server as a background process

import subprocess
process = subprocess.Popen("ollama serve", shell=True)

STEP 6: Pull DeepSeek R-1 model from Ollama model hub

!ollama run deepseek-r1:1.5b

This will download DeepSeek R-1 1.5 billion parameter model

STEP 7: Chat with the model

import ollama

result = ollama.chat(
    model='deepseek-r1:1.5b',
    messages=[{
        'role': 'user',
        'content': 'What are the steps involved in baking a chocolate cake?'
    }],
)

print(result.message.content)

By following the above steps, you can easily run open-source models in a Kaggle notebook, including DeepSeek models, using Ollama.

Here is an existing notebook that implements all the above-mentioned steps: https://github.com/Ifeanyi55/OllamaRun/blob/main/ollamarun.ipynb

Transcription & Translation App Powered by Assembly AI & Google Gemini

Ifeanyi Idiaye — Tue, 19 Nov 2024 19:51:54 +0000

This is a submission for the AssemblyAI Challenge : Sophisticated Speech-to-Text.

What I Built

I built a web application that captures live audio recording, via a web microphone; transcribes the recording, and then translates the transcript into any of 15 languages.

Demo

https://transcribe-and-translate.netlify.app/

Journey

I used AssemblyAI's Universal-2 Speech-to-Text model's api to transcribe the audio recording. I got the API key from my AssemblyAI account dashboard. I built an audio transcriber function, which takes an audio file and passes that to AssemblyAI's transcriber function (aai.Transcriber()), which turns the speech into text.

Along with the audio transcription, I also implemented a translation feature using Google's Gemini 1.5 pro 002 model. This feature leverages the multi-modal capability of Google Gemini models to translate the audio transcript into any of 15 languages, including Spanish, Hindi, Yoruba, and Dutch.

You can find all the code on github: https://github.com/Ifeanyi55/Transcribe-and-Translate