DEV Community: Josmel Noel

I Built an App Without Code — Just Prompts and Firebase Studio

Josmel Noel — Thu, 17 Apr 2025 18:30:28 +0000

What if I told you that you can build a real app — without writing a single line of code — just by typing prompts?

That’s exactly what I did with Firebase Studio, Google’s new visual development tool that brings AI and no-code app building into one place.

Let me walk you through how it works and how you can try it today.

🚀 What Is Firebase Studio?

Firebase Studio is a new tool by Google that lets you build apps using natural language prompts. Think of it as ChatGPT meets app development — but backed by Firebase.

It’s currently in early preview, but already shows huge potential for prototyping apps fast, without needing to write code or even touch an IDE.

🧪 How I Built an App with Just Prompts

I signed into studio.firebase.google.com, and instead of creating UI screens and models manually, I just typed a prompt like:

"Build a mobile app for tracking daily habits with user authentication and cloud sync."

Firebase Studio instantly generated:

A working app scaffold
Firebase Authentication integration
Firestore database setup
UI screens for login, dashboard, and habit tracking

All of this, without writing a single line of code. 🤯

🛠️ Under the Hood

Firebase Studio uses a mix of:

Generative AI to understand prompts
Pre-built Firebase integrations (Auth, Firestore, Hosting, etc.)
A visual editor for tweaks and data modeling
Built-in deploy to Firebase Hosting or Cloud Functions

You can still dig into the generated code if you want — but you don’t have to.

🧑‍💻 Who Should Try This?

🧪 Hackathon devs building MVPs
🧠 Non-technical founders validating ideas
💻 Devs exploring low-code tooling
🧱 Firebase fans looking to speed up scaffolding

✨ Final Thoughts

Firebase Studio is still early, but it feels like a sneak peek into the future of how we’ll build apps: fast, collaborative, and powered by AI.

Want to try it? 👉 studio.firebase.google.com

If you give it a shot, let me know what you build!

🔗 Related:

Vector Search in Practice: Using Embeddings with FAISS and Chroma

Josmel Noel — Mon, 14 Apr 2025 15:52:49 +0000

Hello, fellow developers! Today, we're going to dive into the world of vector search using two powerful libraries: FAISS and Chroma. We'll see how these tools can help us build efficient and effective search solutions, especially in the context of large-scale text data.

Prerequisites

Before we begin, make sure you have Python 3.x installed on your machine. Additionally, you should install the following packages:

pip install faiss torch pandas

For Chroma, follow the installation guide.

Understanding Embeddings

Embeddings are a way to represent words or documents as vectors in a lower-dimensional space while preserving their semantic meaning. This makes it possible to perform vector operations on these representations, such as calculating similarity between them, which can be useful for tasks like search and recommendation systems.

Using FAISS for Vector Search

FAISS (Facebook AI Similarity Search) is a library developed by Facebook AI Research for efficient similarity search and clustering of dense vectors. We'll use FAISS to perform vector search on our precomputed embeddings.

First, let's prepare some sample data:

import pandas as pd
from torch.nn import TextCNN

# Load some text data (e.g., from a CSV file)
data = pd.read_csv('data.csv')

# Define and train a TextCNN model to extract features (embeddings) for our text data
model = TextCNN(...)  # Define your own TextCNN architecture here
X = model(data['text'])  # Extract embeddings from the text data

Now, let's index our embeddings using FAISS:

from faiss.index import IndexFlatIP

n_dim = X.shape[1]
index = IndexFlatIP(n_dim)  # Create a flat IP (Inner Product) index
index.add(X)  # Add our embeddings to the index

Finally, we can search for similar vectors using the search() method:

query = X[0]  # Use any query vector you want
D, I = index.search(query, k=5)  # Find the top-k nearest neighbors
print("Top 5 nearest neighbors:", [(data['text'][i], D[i]) for i in I])

Using Chroma for Embeddings and Vector Search

Chroma is a tool developed by Hugging Face that simplifies the process of working with embeddings and vector search. It provides pre-trained models for extracting text embeddings, as well as a simple API for performing search operations.

First, let's prepare some sample data:

from chromadavis.text_index.simple import SimpleTextIndex

# Load some text data (e.g., from a CSV file)
data = pd.read_csv('data.csv')

# Create a simple text index using Chroma and add our text data to it
index = SimpleTextIndex(pretrained='distilbert-base-nli-mean-tokens')
index.add_documents(data['text'])

Now, we can perform vector search on our index:

query = data['text'][0]  # Use any query you want
results = index.query(query)
print("Top 5 nearest neighbors:", [(d, score) for d, score in results[:5]])

Wrapping Up

In this post, we've seen how to use FAISS and Chroma for efficient vector search on text data. By representing our data as embeddings and performing similarity searches, we can build powerful search solutions that provide relevant results quickly. Give it a try in your next project, and let us know how it goes!

Understanding embedding models and how to use them in search

Josmel Noel — Mon, 14 Apr 2025 15:48:30 +0000

Hello, fellow developers! Today, we're diving into the fascinating world of embedding models and exploring their role in enhancing search functionality. By the end of this post, you'll have a solid understanding of what embedding models are, how they work, and most importantly, how to use them to improve your search applications. Let's get started!

What Are Embedding Models?

Embedding models are a powerful technique used in machine learning to convert categorical data into a continuous vector space. This transformation allows for more efficient computation and the ability to perform vector operations on the data, such as similarity calculations. In essence, embedding models help us find patterns and relationships in our data that would be otherwise difficult to discern.

Why Use Embedding Models in Search?

In search applications, embedding models can significantly boost performance by understanding the semantic meaning of user queries and documents. This understanding allows for more accurate and relevant results, as it considers the context and nuances of language rather than just matching exact phrases.

A Simple Example: Word2Vec

One popular embedding model is Word2Vec, which learns word representations that capture their semantic meaning by modeling local contexts around each word. Let's see how we can use Word2Vec for a simple search application using Python and the Gensim library.

from gensim.models import Word2Vec
from gensim.corpora.Dictionary import Dictionary

# Sample documents
documents = [
    ["apple", "fruit", "red"],
    ["banana", "yellow", "fruit"],
    ["orange", "citrus", "fruit"]
]

# Initialize Word2Vec model with default parameters
model = Word2Vec(documents, min_count=1)

# Get the word vector for 'apple'
apple_vector = model.wv["apple"]

In this example, we first define some sample documents and create a Word2Vec model from them. After training the model, we can retrieve the vector representation of the word "apple."

Searching with Embedding Models

To search for relevant documents using our trained Word2Vec model, we can calculate the cosine similarity between the query vector and each document vector in our corpus. Here's how:

def search(model, query, top_n=5):
    # Get the query vector
    query_vector = model.wv[query]

    # Calculate cosine similarity between the query and each document
    scores = [cosine_similarity(query_vector, doc_vector) for doc_vector in model.wv.vectors]

    # Sort documents by score and return top n results
    sorted_scores_indices = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)[:top_n]
    top_documents = [documents[i] for i in sorted_scores_indices]

    return top_documents

In the above function, we define a search() function that accepts our Word2Vec model and a query string. It retrieves the vector representation of the query, calculates the cosine similarity between the query vector and each document vector in our corpus, and returns the top n results based on the calculated scores.

Wrapping Up

Embedding models are a powerful tool for enhancing search functionality by understanding the semantic meaning of user queries and documents. In this post, we learned about Word2Vec, a popular embedding model, and saw how to use it for a simple search application in Python with Gensim. By incorporating embedding models into your search applications, you can provide more accurate and relevant results that cater to the context and nuances of language.

Happy coding!

How to build an AI agent using Python

Josmel Noel — Thu, 10 Apr 2025 19:45:05 +0000

# Building an AI Agent Using Python

Welcome, fellow developers! Today we're going to dive into creating an AI agent using Python. This tutorial assumes you have a basic understanding of Python and some familiarity with AI tools. Let's get started!

Prerequisites

To follow along, ensure you have the following:

Python 3.x installed (you can check your version by running python --version in your terminal)
A text editor or IDE of your choice (e.g., Visual Studio Code, PyCharm, etc.)
The TensorFlow library for machine learning (pip install tensorflow)
Scikit-learn library for machine learning (pip install scikit-learn)
Numpy library for numerical computations (usually included by default with Python)
A dataset to train our AI agent

Creating Our AI Agent

For this tutorial, we'll create a simple reinforcement learning agent that plays the cartpole game as an example of an AI problem.

First, let's import the necessary libraries:

import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from cartpole_env import CartPoleEnv

Here we're using TensorFlow for creating our neural network and cartpole_env for our environment. The CartPoleEnv is a built-in environment from the OpenAI Gym library that simulates balancing a pole on a cart.

Defining the Neural Network

Next, we'll define our neural network architecture:

def create_model():
    model = Sequential()
    model.add(Dense(16, input_dim=4, activation='relu'))  # Input layer
    model.add(Dense(16, activation='relu'))            # Hidden layer
    model.add(Dense(2))                                # Output layer
    return model

Interacting with the Environment

Now let's write a function to interact with our environment and learn from its experiences:

def play_cartpole(model, env, num_episodes=100):
    scores = []
    for episode in range(num_episodes):
        state = env.reset()
        score = 0
        while True:
            action = model.predict([state])[0]
            next_state, reward, done, _ = env.step(action)
            score += reward
            state = next_state
            if done or episode == num_episodes - 1:
                break
        scores.append(score)
    return np.mean(scores), scores

Training the AI Agent

Finally, let's train our agent and play some games:

if __name__ == "__main__":
    env = CartPoleEnv()
    model = create_model()

    for layer in model.layers:
        layer.trainable = True  # Set all layers to be trainable

    num_episodes = 500
    best_score, best_scores = play_cartpole(model, env, num_episodes)
    print("Average score:", best_score)

Conclusion

There you have it! A simple AI agent built using Python and TensorFlow. You can tweak the parameters, change the environment, or even try other reinforcement learning algorithms to enhance this project further.

Keep learning and experimenting with different AI problems and techniques – the field of AI is constantly evolving! Happy coding!

Building multi-agent systems with LangGraph or CrewAI

Josmel Noel — Thu, 10 Apr 2025 05:40:28 +0000

# Building Multi-Agent Systems with LangGraph or CrewAI

Hello, fellow AI enthusiasts! Today, we're diving into the fascinating world of multi-agent systems using two powerful tools: LangGraph and CrewAI. By the end of this post, you'll have a solid understanding of how to set up, train, and deploy these systems using Python. Let's get started!

Prerequisites

Before we dive into the code, make sure you have:

A modern version of Python (3.6+) installed on your machine.
Familiarity with Python libraries such as NumPy, Pandas, and TensorFlow or PyTorch.
Git to clone repositories and manage your project.
Docker for easier environment setup and deployment.

Introduction to LangGraph and CrewAI

Both LangGraph and CrewAI are tools designed to simplify the development of multi-agent systems. LangGraph provides a flexible framework for defining, training, and deploying agents in various environments, while CrewAI offers a more user-friendly interface for creating and managing multi-agent simulations.

Setting Up LangGraph

To get started with LangGraph, first, clone the repository from GitHub:

git clone https://github.com/langtechai/langgraph.git
cd langgraph
pip install .

Next, let's create a simple environment for our agent to navigate using the EnvBuilder class:

from langgraph import EnvBuilder, Agent, ActionSpace, ObservationSpace

class MyEnvironment(EnvBuilder):
    def __init__(self, width=80, height=60):
        self.width = width
        self.height = height
        super().__init__()

    def _reset(self):
        self.observation_space = ObservationSpace({'x': 0, 'y': 0})
        self.action_space = ActionSpace(['up', 'down', 'left', 'right'])
        self._reset_env()

    def _step(self, action):
        # Implement the logic of your environment here.
        pass

Now, create an agent that can move around our environment:

class MyAgent(Agent):
    def __init__(self, observation_space, action_space):
        super().__init__(observation_space, action_space)

    def choose_action(self, observation):
        # Implement your agent's decision-making logic here.
        pass

Finally, let's run a training session for our agent:

from langgraph import Trainer

def main():
    environment = MyEnvironment()
    agent = MyAgent(environment.observation_space, environment.action_space)
    trainer = Trainer(agent, environment, nb_episodes=1000)
    trainer.train()

if __name__ == "__main__":
    main()

Setting Up CrewAI

To use CrewAI, first, sign up for an account and create a new project at CrewAI. Clone the provided starter repository to your local machine:

git clone https://github.com/<YOUR_USERNAME>/<PROJECT_NAME>.git
cd <PROJECT_NAME>
pip install -r requirements.txt

Next, open the config.yaml file and modify it according to your project's needs. This includes defining the environment, agents, training parameters, and more.

Finally, run the training script using Docker:

docker build -t <IMAGE_NAME> .
docker run -it --rm --name <CONTAINER_NAME> <IMAGE_NAME>

Conclusion

In this post, we explored how to build multi-agent systems using LangGraph and CrewAI. Both tools provide a powerful foundation for creating complex AI simulations, and their Python-based nature makes them accessible to developers familiar with the language. By leveraging these tools, you can focus on developing intelligent agents and leave the environment setup and training to the frameworks. Happy coding!

Fine-tuning LLMs locally: A step-by-step guide

Josmel Noel — Wed, 09 Apr 2025 04:42:28 +0000

# Fine-Tuning LLMs Locally: A Step-by-Step Guide

Hello fellow developers! Today, we're going to delve into the exciting world of fine-tuning Language Model Libraries (LLMs) locally. This guide is designed for AI enthusiasts familiar with Python and common AI tools. Let's get started!

Prerequisites

A basic understanding of Python programming language
Familiarity with AI concepts, particularly Natural Language Processing (NLP)
Installation of PyTorch or TensorFlow
A suitable LLM library such as Hugging Face's Transformers or Stanford's CoreNLP
Dataset for training the model (preferably labeled)

Step 1: Preparing the Data

The first step is to prepare your data for fine-tuning. This usually involves tokenizing your text and converting it into a format that the LLM can understand. Here's an example using the Transformers library:

from transformers import BertTokenizerFast

tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased')

def preprocess_function(examples):
    return {'input_ids': tokenizer.encode(examples['text'], add_special_tokens=True)}

train_dataset = dataset.map(preprocess_function, batched=True)

In this example, we're using the BERT model for demonstration purposes. Replace 'bert-base-uncased' with the path to your preferred pre-trained LLM.

Step 2: Defining the Training Loop

Next, we define a training loop that uses our prepared data and optimizes the weights of the model. Here's an example using PyTorch:

import torch
from transformers import BertForSequenceClassification, Trainer, TrainingArguments

model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)

training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset
)

trainer.train()

In this example, we're using the Trainer class from Hugging Face's Transformers library to handle training and evaluation for us.

Step 3: Running the Training Process

Once you have your training loop defined, it's time to run the training process! Save your script, navigate to the directory containing your file in your terminal, and run the script with the following command:

python train.py

This will start the training process, logging progress and storing checkpoints at specified intervals. Once training is complete, you can load the fine-tuned model for downstream tasks!

Wrapping Up

And there you have it! You've successfully fine-tuned a Language Model Library locally. Keep exploring, experimenting with different models and datasets, and pushing the boundaries of what AI can do. Happy coding!

Prompt engineering techniques with LLMs

Josmel Noel — Wed, 09 Apr 2025 04:34:03 +0000

# Prompt Engineering Techniques with LLMs: A Comprehensive Guide for Developers

In the rapidly evolving landscape of Artificial Intelligence (AI), Large Language Models (LLMs) have emerged as powerful tools that can generate human-like text. This post aims to delve into the art and science of prompt engineering, a crucial technique to guide these models towards producing more accurate and useful responses.

Understanding Prompt Engineering

Prompt engineering is the process of crafting effective prompts to elicit specific and high-quality outputs from LLMs. It's about speaking the model's language to get the best results.

def generate_response(model, prompt):
    return model.generate(prompt)

# Initialize a large language model (LLM)
llm = SomeLargeLanguageModel()  # Replace with your preferred LLM library

# Define a simple prompt
simple_prompt = "What is the capital of France?"
response = generate_response(llm, simple_prompt)
print(response.strip())  # Output: 'Paris'

In this example, we've created a simple function to interact with an LLM. While this works fine for straightforward queries, real-world scenarios often require more nuanced prompts.

Techniques for Effective Prompt Engineering

1. Be Specific and Clear

The model needs clear instructions to generate accurate results. For instance, instead of "Write about a dog," say "Describe a Labrador Retriever in detail."

detailed_prompt = "Please describe a Labrador Retriever in detail."
response = generate_response(llm, detailed_prompt)
print(response.strip())  # Output: A detailed description of a Labrador Retriever

2. Use Relevant Context

Provide the model with context relevant to the task at hand. This helps improve the model's understanding and response quality.

contextual_prompt = "You are an expert on cars. Which car has the largest cargo space among SUVs?"
response = generate_response(llm, contextual_prompt)
print(response.strip())  # Output: An answer about SUVs with large cargo spaces

3. Ask Yes/No Questions Wisely

Asking yes/no questions can be effective, but be mindful of the model's understanding of negation. Consider rephrasing negative prompts as affirmative ones.

# Inefficient prompt (avoid asking yes/no directly)
yes_no_prompt = "Is Paris not the capital of France?"
response = generate_response(llm, yes_no_prompt)
print(response.strip())  # Output: 'False'

# Efficient prompt (rephrase negation to affirmative)
affirmative_prompt = "What is not the capital of France?"
response = generate_response(llm, affirmative_prompt)
print(response.strip())  # Output: A city other than Paris

4. Leverage Multiple Prompts and Combine Responses

If a single prompt doesn't provide the desired information, try breaking down the task into multiple prompts and combining the responses.

# Break down the task into simpler steps
prompt1 = "Who is the current president of the United States?"
response1 = generate_response(llm, prompt1)
print(response1.strip())  # Output: The name of the US President

prompt2 = f"In which state was {response1} born?"
response2 = generate_response(llm, prompt2)
print(response2.strip())  # Output: The state where the US President was born

Embrace the Power of Prompt Engineering

Prompt engineering is a powerful technique that empowers developers to harness the potential of LLMs effectively. By following these techniques, you can guide your models towards generating high-quality and relevant responses, thereby enhancing the AI applications you create. Happy coding!

Introduction to TensorFlow with real code examples

Josmel Noel — Wed, 09 Apr 2025 04:09:42 +0000

# Introduction to TensorFlow with Real Code Examples

Hello, fellow developers! Today, we're going to embark on an exciting journey into the world of Machine Learning (ML) using one of the most popular open-source ML libraries - TensorFlow. This post will guide you through setting up your environment, understanding its core concepts, and providing real code examples to help you get started with this powerful tool.

Prerequisites

Before we dive in, let's ensure that you have the following prerequisites met:

Familiarity with Python programming language
Basic understanding of Machine Learning concepts
A working development environment on your machine (MacOS/Linux/Windows)

Installing TensorFlow

Using pip

You can install TensorFlow using pip, which is a package manager for Python. Here's the command you need to run in your terminal or command prompt:

pip install tensorflow

If you want to use GPU-accelerated computations, ensure that CUDA is installed on your machine and use the following command instead:

pip install tensorflow-gpu

Using Colab (Google's Jupyter notebook environment)

If you don't want to set up TensorFlow locally, you can use Google Colab, which comes with a GPU by default. You can access it via this link.

Understanding TensorFlow

TensorFlow is an end-to-end open-source platform for ML. It consists of:

TensorFlow Core: The primary library that provides the basic functionality of constructing and running computational graphs.
TensorFlow Lite: A lightweight version for mobile and embedded devices.
TensorFlow Hub: A repository of pre-trained ML models, tools, and utilities to help you easily integrate them into your projects.
TensorBoard: A powerful visualization tool for exploring and understanding the structure and performance of your ML models.

Creating Your First TensorFlow Program

Let's create a simple neural network using TensorFlow to approximate the function y = x^2. Here's the code:

import tensorflow as tf
from tensorflow import keras

# Define input and output shapes for our model
x_input = tf.keras.Input(shape=(1,))
y_output = keras.layers.Dense(units=1)(x_input)

# Create a model instance
model = keras.Model(inputs=x_input, outputs=y_output)

# Compile the model with Mean Squared Error loss function and Adam optimizer
model.compile(optimizer='adam', loss='mean_squared_error')

# Create a dataset
data = tf.data.Dataset.from_tensor_slices((tf.random.uniform((1000, 1), maxval=100), tf.range(100)))
data = data.shuffle(1000).batch(32)

# Train the model for a specified number of epochs
model.fit(data, epochs=50)

This code creates a simple neural network with one input (x), one output (y), and one hidden layer (Dense layer). It then compiles the model with the Mean Squared Error loss function and Adam optimizer. After creating a dataset for training, it trains the model for 50 epochs.

We hope this introduction to TensorFlow has been helpful! In future posts, we'll explore more advanced topics such as building convolutional neural networks, using TensorBoard, and integrating TensorFlow with other AI tools. Stay tuned!

Happy coding! :)

🧠 Build a Smart Internal Knowledge Chatbot with Embeddings and Vector Databases

Josmel Noel — Tue, 08 Apr 2025 17:35:55 +0000

Struggling to find info buried deep in your company's documents? Let’s build a chatbot that can understand your questions and retrieve accurate answers from thousands of PDFs, manuals, and wikis—powered by LLMs + Vector Databases.

🔍 What We'll Build

A semantic search-based chatbot that can answer employee questions like:

“What’s the company’s remote work policy?”
“How do I request PTO?”
“Where’s the VPN setup guide?”

No more digging through folders. Just ask.

🧠 How It Works

We’ll use a Retrieval-Augmented Generation (RAG) architecture:

📄 Split documents into chunks
🔢 Embed them using OpenAI or Sentence-BERT
🧠 Store in a vector database (e.g., Chroma, FAISS, Pinecone)
🤖 Search similar chunks based on user queries
💬 Generate answers with GPT-4 using the retrieved context

⚙️ Tech Stack

Component	Tool
Embedding Model	OpenAI or Sentence-BERT
Vector Database	Chroma (local & fast)
LLM	OpenAI GPT-4
Loader & Splitter	LangChain utilities
Optional Frontend	Streamlit or FastAPI

🧪 Step-by-Step Code Example

pip install langchain openai chromadb

from langchain.document_loaders import DirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chat_models import ChatOpenAI
from langchain.chains.qa_with_sources import load_qa_with_sources_chain

# 1. Load documents
loader = DirectoryLoader('./docs')  # Folder of .txt or PDFs
documents = loader.load()

# 2. Split into chunks
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)
docs = splitter.split_documents(documents)

# 3. Embed and store
embeddings = OpenAIEmbeddings()
vectordb = Chroma.from_documents(docs, embeddings)

# 4. Query from user
query = "What is the company’s policy on remote work?"
retrieved_docs = vectordb.similarity_search(query, k=3)

# 5. Generate answer using LLM
llm = ChatOpenAI(temperature=0)
qa_chain = load_qa_with_sources_chain(llm, chain_type="stuff")
result = qa_chain.run(input_documents=retrieved_docs, question=query)

print(result)

🚀 Ready to Scale?

For production, consider using:

✅ Pinecone or Weaviate for scalable vector storage
🔒 Secure LLMs with prompt templates
🖥️ Frontend using Streamlit or chatbot widget

📚 Real-World Use Cases

HR Knowledgebase Assistant
Legal Document Search Bot
Customer Support Answer Bot
Onboarding Helpdesk

🙌 Wrapping Up

By combining LLMs + vector embeddings, you unlock next-level document search—context-aware, semantically smart, and actually useful.

Got questions or building your own chatbot? Let’s connect in the comments! 💬

Automating IT Interviews with Ollama and Audio Capabilities in Python

Josmel Noel — Fri, 05 Jul 2024 15:33:37 +0000

In today’s tech-driven world, automation is revolutionizing recruitment. Imagine having a virtual IT interviewer that not only interacts intelligently but also communicates verbally with candidates. This post will guide you through building an IT interviewer using Ollama and Python, integrating audio capabilities for a more immersive experience.

📚 Introduction
Finding the right talent can be challenging and time-consuming. With advancements in AI and audio processing, it's possible to automate the initial interview phase. This project showcases how to create an interactive IT interviewer that asks questions and processes answers through voice, using Ollama and Google Cloud's Speech-to-Text and Text-to-Speech APIs.

🚀 What You Will Learn

How to set up Ollama for conversation handling.
Integrate Google Cloud’s Speech-to-Text and Text-to-Speech APIs for audio capabilities.
Structure a Python project to automate interviews.

🛠️ Prerequisites

Python 3.7+
Google Cloud Account: For Speech-to-Text and Text-to-Speech APIs.
Ollama Account: For conversational AI.

📂 Project Setup
1. Clone the Repository
Start by cloning the project repository:

git clone https://github.com/josmel/ollama-it-interviewer.git
cd ollama-it-interviewer

2. Create and Activate a Virtual Environment
Set up a virtual environment to manage dependencies:

python -m venv venv
source venv/bin/activate

3. Install Dependencies
Install the required Python packages:

pip install -r requirements.txt

4. Configure Google Cloud
a. Enable the APIs
Enable the Speech-to-Text and Text-to-Speech APIs in your Google Cloud Console.

b. Create Service Account and Download JSON Key

Go to IAM & Admin > Service accounts.
Create a new service account, grant it the necessary roles, and download the JSON credentials file.

c. Set the Environment Variable
Set the environment variable to point to your credentials file

export GOOGLE_APPLICATION_CREDENTIALS="/path/to/your/service-account-file.json"

Replace /path/to/your/service-account-file.json with the actual path to your credentials file.

Prepare Audio Files
Add sample audio files in the audio_samples/ directory. You need a candidate-response.mp3 file to simulate a candidate's response. You can record your voice or use text-to-speech tools to generate this file.
Update Configuration
Edit src/config.py to configure your Ollama credentials:

OLLAMA_API_URL = 'https://api.ollama.com/v1/conversations'  # Or replace with your Ollama local
OLLAMA_MODEL = 'your-ollama-model'  # Replace with your Ollama model

7. Run the Project
Run the interviewer script:

# Option 1: Run as a module from the project root
python3 -m src.interviewer

# Option 2: Ensure PYTHONPATH is set and run directly
export PYTHONPATH=$(pwd)
python3 src/interviewer.py

📝 Detailed Explanation
interviewer.py
The main script orchestrates the interview process:

from pydub import AudioSegment
from pydub.playback import play
from src.ollama_api import ask_question
from src.speech_to_text import recognize_speech
from src.text_to_speech import synthesize_speech
from dotenv import load_dotenv
import os

# Load environment variables
load_dotenv()

# Configure FFmpeg for macOS/Linux
os.environ["PATH"] += os.pathsep + '/usr/local/bin/'

def main():
    question = "Tell me about your experience with Python."
    synthesize_speech(question, "audio_samples/question.mp3")

    question_audio = AudioSegment.from_mp3("audio_samples/question.mp3")
    play(question_audio)

    candidate_response = recognize_speech("audio_samples/candidate-response.mp3")

    ollama_response = ask_question(candidate_response)
    print(f"Ollama Response: {ollama_response}")

    synthesize_speech(ollama_response, "audio_samples/response.mp3")

    response_audio = AudioSegment.from_mp3("audio_samples/response.mp3")
    play(response_audio)

if __name__ == "__main__":
    main()

ollama_api.py
Handles interaction with Ollama API:

import requests
from src.config import OLLAMA_API_URL, OLLAMA_MODEL

def ask_question(question):
    response = requests.post(
        OLLAMA_API_URL,
        json={"model": OLLAMA_MODEL, "input": question}
    )
    response_data = response.json()
    return response_data["output"]

Converts audio to text using Google Cloud:

from google.cloud import speech
import io

def recognize_speech(audio_file):
    client = speech.SpeechClient()

    with io.open(audio_file, "rb") as audio:
        content = audio.read()

    audio = speech.RecognitionAudio(content=content)
    config = speech.RecognitionConfig(
        encoding=speech.RecognitionConfig.AudioEncoding.MP3,
        sample_rate_hertz=16000,
        language_code="en-US",
    )

    response = client.recognize(config=config, audio=audio)
    for result in response.results:
        return result.alternatives[0].transcript

text_to_speech.py
Converts text to audio using Google Cloud:

from google.cloud import texttospeech
import os

def synthesize_speech(text, output_file):
    # Verify that the environment variable is set
    assert 'GOOGLE_APPLICATION_CREDENTIALS' in os.environ, "GOOGLE_APPLICATION_CREDENTIALS not set"

    client = texttospeech.TextToSpeechClient()

    synthesis_input = texttospeech.SynthesisInput(text=text)
    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US",
        ssml_gender=texttospeech.SsmlVoiceGender.NEUTRAL
    )
    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.MP3
    )

    response = client.synthesize_speech(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    with open(output_file, "wb") as out:
        out.write(response.audio_content)
        print(f"Audio content written to file {output_file}")

🎉 Conclusion
By integrating Ollama and Google Cloud’s audio capabilities, you can create a virtual IT interviewer that enhances the recruitment process by automating initial candidate interactions. This project demonstrates the power of combining conversational AI with audio processing in Python.

Give it a try and share your thoughts in the comments! If you encounter any issues or have suggestions, feel free to ask.

📂 Project Structure

ollama-it-interviewer/
│
├── audio_samples/
│   ├── candidate-response.mp3
│
├── src/
│   ├── interviewer.py
│   ├── ollama_api.py
│   ├── speech_to_text.py
│   ├── text_to_speech.py
│   └── config.py
│
├── requirements.txt
├── README.md
└── .gitignore

🛠️ Resources

Ollama
Google Cloud Speech-to-Text
Google Cloud Text-to-Speech
Python pydub

💬 Questions or Comments?
Feel free to leave any questions or comments below. I’m here to help!

Repository : https://github.com/josmel/ollama-it-interviewer

Mastering Recursion: A Byte-Sized Explanation

Josmel Noel — Thu, 20 Jun 2024 21:42:46 +0000

This is a submission for DEV Computer Science Challenge v24.06.12: One Byte Explainer.

Explainer

Recursion: A function calls itself to solve smaller instances of a problem. Useful for tasks like tree traversal and factorial calculation. Efficient but can lead to stack overflow if not handled properly.

Additional Context

Recursion simplifies complex problems by breaking them down into manageable parts, making code easier to write and understand. However, it requires careful handling of base cases to prevent infinite loops.

Exploring Kotlin Coroutines for Asynchronous Programming

Josmel Noel — Tue, 18 Jun 2024 22:06:27 +0000

Asynchronous programming is essential for modern applications to handle tasks like network calls, file I/O, or heavy computations without blocking the main thread. Kotlin coroutines provide a robust and efficient way to manage such tasks.

How Coroutines Work
Kotlin coroutines enable writing asynchronous code in a sequential style. Key components include:

CoroutineScope: Defines the scope in which coroutines run, ensuring structured concurrency.
Suspend Functions: Functions marked with suspend can pause their execution and resume later, allowing non-blocking operations.
Launch and Async: Functions to start coroutines. launch is used for fire-and-forget tasks, while async is used for tasks that return a result.

Example: Basic Coroutine

fun main() = runBlocking {
    launch {
        delay(1000L)
        println("World!")
    }
    println("Hello,")
}

In this example, launch starts a new coroutine, and delay is a suspend function that pauses the coroutine without blocking the main thread.

Use Cases and Examples

1. Network Requests:
Using coroutines to handle network requests prevents blocking the UI thread.

suspend fun fetchData(): String {
    return withContext(Dispatchers.IO) {
        apiService.getData()
    }
}

2. Parallel Decomposition:
Running multiple tasks concurrently to improve performance.

runBlocking {
    val deferred1 = async { task1() }
    val deferred2 = async { task2() }
    println("Results: ${deferred1.await()} and ${deferred2.await()}")
}

3. UI Updates:
Ensuring smooth UI updates by switching contexts.

GlobalScope.launch(Dispatchers.Main) {
    val data = withContext(Dispatchers.IO) { fetchData() }
    updateUI(data)
}

4. Handling Timeouts:
Managing tasks with time constraints.

runBlocking {
    withTimeout(1000L) {
        val result = longRunningTask()
        println("Result: $result")
    }
}

5. Structured Concurrency:
Ensuring coroutines are properly scoped and cancelled.

fun CoroutineScope.massiveRun(action: suspend () -> Unit) {
    val jobs = List(100_000) {
        launch {
            repeat(1000) { action() }
        }
    }
    jobs.forEach { it.join() }
}

Conclusion
Kotlin coroutines offer a powerful model for handling asynchronous tasks, making code more readable and maintainable. By utilizing coroutine scopes, suspend functions, and structured concurrency, developers can build efficient and responsive applications. Coroutines are particularly beneficial for tasks such as network requests, parallel computations, UI updates, handling timeouts, and ensuring structured concurrency.

For further reading, explore the official Kotlin coroutines guide.