DEV Community: Shelwyn Corte

Python chatbot under 10 lines of code.

Shelwyn Corte — Fri, 16 May 2025 06:00:53 +0000

Here is how you can create a #python #chatbot under 10 lines of code leveraging #googleGemini LLM

1 - Hit https://aistudio.google.com/apikey and get yourself an FREE API-KEY
2 - install python and pip install google-generative-ai
3 - create a python file (bot.py), use the below code

Beyond YOLO: Implementing D-FINE Object Detection for Superior Precision

Shelwyn Corte — Sat, 10 May 2025 03:33:47 +0000

Object detection remains one of the most practical and widely applied tasks in computer vision. While YOLO (You Only Look Once) has dominated this space for years with its speed and simplicity, a new approach is gaining traction among researchers and practitioners looking for improved accuracy: D-FINE.

Code and instructions

Build a Speaking RAG Locally

Shelwyn Corte — Mon, 17 Mar 2025 04:59:44 +0000

Here is link to the git repo: https://github.com/shelwyn/fox

Build Your Own Offline AI Chatbot: Running DeepSeek Locally with Ollama

Shelwyn Corte — Fri, 07 Feb 2025 11:16:42 +0000

get the complete code here

Build Your Own Free AI Chatbot: A Step-by-Step Guide Using DeepSeek and FastAPI

Shelwyn Corte — Wed, 29 Jan 2025 14:49:50 +0000

Create a powerful chatbot with 1,000 free daily requests — no paid APIs needed!
I’ll walk you through creating a simple yet powerful chatbot using DeepSeek’s language model, FastAPI, and plain HTML/JavaScript — all while staying within the free tier of HuggingFace’s Inference API.

GitHub Repository: [try-deepSeek-ai]

Capture and stream video on browser with Python-FLASK

Shelwyn Corte — Tue, 21 Jan 2025 11:45:46 +0000

Read the complete article (With code) on Medium

Remember Agent Smith from The Matrix? 🕴️

Shelwyn Corte — Fri, 08 Nov 2024 14:44:14 +0000

That iconic scene where he multiplies into countless clones, each single-mindedly pursuing their mission to maintain order in the system.

Fast forward to 2024, and we're witnessing something fascinating:

Instead of Agent Smith, we're creating AI agents powered by Large Language Models (LLMs). Like Smith's clones, these digital assistants are being deployed across different tasks:
• Writing code 💻
• Analyzing data 📊
• Managing customer service 🤝
• Automating workflows ⚙️

But here's the key difference: Unlike Smith's clones who sought to control, these AI agents are designed to collaborate and empower. They're not here to trap us in a system, but to help us break free from mundane tasks and unlock our creative potential.

The "Matrix" we're building isn't a prison - it's a scaffold for human innovation.

What tasks would you delegate to your AI "Agent Smith"? 🤔

ArtificialIntelligence #Matrix #Technology #Innovation #FutureOfWork #AI #LLM #DigitalTransformation

Translate speech to any language (Google supported) with Python and Google Translate API

Shelwyn Corte — Fri, 08 Nov 2024 06:42:19 +0000

In this article, we are going to create a speech translator with python using the Google translate API

Installation (Linux):
— pip install SpeechRecognition
— pip install googletrans
— pip install gTTS
— pip install playsound

Installation (Windows):
— pip install SpeechRecognition
— pip install gTTS
— pip install pipwin
— pipwin install pyaudio
— pip install playsound==1.2.2
— pip install googletrans==4.0.0-rc1

Lets import the required modules

import speech_recognition as sr
from googletrans import Translator
from gtts import gTTS
from playsound import playsound

Create an object of the translator class

translator = Translator()

We will now use the default microphone as the audio source, listen to the phrase and extract it into audio data

r = sr.Recognizer()
with sr.Microphone() as source:
    print("Speak Now:")
    audio = r.listen(source)

Set the destination language, you can get a list of all language codes here [https://meta.wikimedia.org/wiki/Template:List_of_language_names_ordered_by_code]

language_to_translate='en'

The below section will print the recognized speech, set the language to be translated to and use the google API to to translate the recognized speech. We will also print the detected text and the translated text on the console

print("Recognized as: ", r.recognize_google(audio))
language = language_to_translate
translations = translator.translate(r.recognize_google(audio), dest=language)
print(translations.origin, ' -> ', translations.text)

Finally we will save the translated text as an mp3 audio file using Google Text-to-Speech and then play it using the playsound library

myobj = gTTS(text=translations.text, lang=language)
myobj.save(tr + ".mp3")
playsound(tr + ".mp3")

*Complete Code:
*

import speech_recognition as sr
from googletrans import Translator
from gtts import gTTS
from playsound import playsound

translator = Translator()
r = sr.Recognizer()
with sr.Microphone() as source:
    print("Speak Now:")
    audio = r.listen(source)

language_to_translate='en'
try:
    print("Recognized as: ", r.recognize_google(audio))
    language = language_to_translate
    translations = translator.translate(r.recognize_google(audio), dest=language)
    print(translations.origin, ' -> ', translations.text)
    myobj = gTTS(text=translations.text, lang=language)
    myobj.save(tr + ".mp3")
    playsound(tr + ".mp3")
except Exception as e:
    print(e)

Create API’s in 5 minutes with Python

Shelwyn Corte — Wed, 23 Oct 2024 06:21:02 +0000

"Create APIs in 5 minutes with FastAPI. A modern, high-performance Python framework, FastAPI makes it easy to build powerful web applications."

Installation
Install FastAPI and uvicorn (ASGI server) using pip:

pip install fastapi uvicorn
pip install fastapi

Lets create our API

Open notepad and paste the below contents, save the file as data.json (we will adding data to this file using the POST method and will be retrieving records using the GET method

data.json

[
   {
      "name": "John",
      "age": 25
   },
   {  "name": "Smith",
      "age": 27
   }
]

Now create a new python file, name it as app.py and paste the below code

# This section imports necessary modules and classes from the FastAPI library and Python's standard library. It imports FastAPI for creating the web application, HTTPException for raising HTTP exceptions, List for type hints, and json for working with JSON data.

from fastapi import FastAPI, HTTPException
from typing import List
import json

# This creates an instance of the FastAPI class, which will be the main application instance for handling HTTP requests.
app = FastAPI()

# This block reads the content of the "data.json" file using a context manager (with statement) and loads the JSON data into the initial_data variable.
with open("data.json", "r") as file:
    initial_data = json.load(file)

# This line initializes the data variable with the loaded JSON data, effectively creating a list of dictionaries containing user information.
data = initial_data

# This decorator (@app.get(...)) defines a GET endpoint at the "/users" URL. It uses the get_users function to handle the request. The response_model parameter specifies the expected response model, which is a list of dictionaries in this case.
@app.get("/users", response_model=List[dict])
async def get_users():
    return data

# This decorator (@app.post(...)) defines a POST endpoint at the "/users" URL. It uses the create_user function to handle the request. The response_model parameter specifies the expected response model, which is a single dictionary in this case.
# The create_user function attempts to append the received user dictionary to the data list. If successful, it constructs a response dictionary indicating the success. If an exception occurs during the attempt (e.g., due to invalid data), it constructs a response dictionary indicating an error.
@app.post("/users", response_model=dict)
async def create_user(user: dict):
    try:
        data.append(user)
        response_data = {"message": "User created successfully", "user": user}
    except:
        response_data = {"message": "Error creating user", "user": user}
    return response_data

# This function uses a context manager to open the "data.json" file in write mode and then uses json.dump to write the contents of the data list back to the file, formatting it with an indentation of 4 spaces.
def save_data():
    with open("data.json", "w") as file:
        json.dump(data, file, indent=4)

# This decorator (@app.on_event(...)) defines a function that will be executed when the FastAPI application is shutting down. In this case, it calls the save_data function to save the data back to the JSON file before the application exits.
@app.on_event("shutdown")
async def shutdown_event():
    save_data()

# This block checks if the script is being run directly (not imported as a module). If it is, it uses the uvicorn.run function to start the FastAPI application on host "0.0.0.0" and port 8000. This is how you launch the application using the Uvicorn ASGI server.
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Run the app.py, Uvicorn server will start a new process to handle incoming HTTP requests. once the server is up and running, open Postman, create a new GET request with the URL: http://0.0.0.0:8000/users and click send

You will see a JSON response with the list of users from the data.json file.

Now lets add an user to this file with POST method. Create a new request, select the POST method, click on body, select raw, select JSON from the dropdown and paste the below JSON as a payload to add a new user

{
    "name": "Tina",
    "age": 22
}

Once you click send, you will get a response back if the user is added successfully with a status code of 200 OK

And that is it, we have successfully created an API with GET/POST method to view and add users to a file. go back to the GET request and click send, you should now see the user Tina also listed in the response of the API.

One amazing thing about FastAPI is that it automatically generates Swagger documentation for your API endpoints, making it easier for developers to understand and use your API effectively.

If you open a browser and type http://localhost:8000/docs you will see a swagger document for the API

Please note, this is just an basic example of creating a quick API with python, you will further need to do more configuration or coding especially in terms of error handling, data validation, and security.