DEV Community: Arish Sethi

AI CHATBOT (JARVIS)

Arish Sethi — Fri, 10 Jul 2026 19:47:15 +0000

Building Jarvis: How I Created a Voice-Activated Python Assistant 🚀

Ever since I started programming, I wanted to build something that felt like it belonged in a sci-fi movie. So, I decided to sit down and create my own virtual voice assistant—Jarvis.

Using Python, I built an assistant that listens to my voice, speaks back to me, opens up my favorite websites, fetches live news headlines, and even plays my favorite tracks from a music dictionary.

Here is a breakdown of how I built it, how the code works, and what I learned along the way!

🛠️ The Tech Stack

To give Jarvis ears, a voice, and web powers, I used a few key Python libraries:

speech_recognition: For capturing audio from my microphone and converting it to text.
pyttsx3: A text-to-speech library that lets Jarvis talk back offline.
webbrowser: To trigger web automation directly from the terminal.
requests: To make API calls and fetch real-time data from the web.

💻 The Full Code

Here is the complete Python script I wrote for Jarvis:

import speech_recognition as sr
import webbrowser
import pyttsx3
import requests

recognizer = sr.Recognizer()
engine = pyttsx3.init()
newsapi = "YOUR_API_KEY"  # Replace with your own key to use this code

# Function to speak a given text
def speak(text):
    engine.say(text)
    engine.runAndWait()

# Songs dictionary with song name and YouTube link
songs = {
    "who they": "[https://www.youtube.com/watch?v=wBw6Leb5F2U](https://www.youtube.com/watch?v=wBw6Leb5F2U)",
    "block": "[https://www.youtube.com/watch?v=e4c5i1fyW-4](https://www.youtube.com/watch?v=e4c5i1fyW-4)"
}

# Function to process recognized commands
def processword(c):
    if "open google" in c.lower():
        webbrowser.open("[https://google.com](https://google.com)")
    elif "open youtube" in c.lower():
        webbrowser.open("[https://youtube.com](https://youtube.com)")
    elif c.lower().startswith("play"):
        song = c.lower().split("play ")[1].strip()
        link = songs.get(song, None)
        if link:
            speak(f"Playing {song}")
            webbrowser.open(link)
        else:
            speak(f"Sorry, I don't have the song {song}.")
    elif "news" in c.lower():
        r = requests.get(f"[https://newsapi.org/v2/top-headlines?country=us&apiKey=](https://newsapi.org/v2/top-headlines?country=us&apiKey=){newsapi}")
        if r.status_code == 200:
            data = r.json()
            articles = data.get("articles", None)
            for article in articles:
                speak(article["title"])

# Main logic
if __name__ == "__main__":
    speak("Initializing Jarvis....")
    while True:
        try:
            # Obtain audio from the microphone
            with sr.Microphone() as source:
                print("Listening...")
                audio = recognizer.listen(source, timeout=3, phrase_time_limit=5)

            # Recognize the keyword 'Jarvis'
            word = recognizer.recognize_google(audio)
            if word.lower() == "jarvis":
                speak("Yes?")
                with sr.Microphone() as source:
                    print("Jarvis active...")
                    audio = recognizer.listen(source)
                    command = recognizer.recognize_google(audio)
                    processword(command)

        except Exception as e:
            print(f"Error: {str(e)}")

📸 See It In Action!

Here is what it looks like when Jarvis initializes and listens through the terminal:

[
]

💡 What I Learned From This Project

API Integration is Powerful: Working with requests to pull real-time news headlines opened my eyes to how modern web applications share data.
Error Handling is Crucial: Wrapping the audio listener in a try/except block kept the program from constantly crashing when it couldn't understand a sentence.
From Python to the Future: Building logic like this gives me a great foundation as I transition into learning lower-level, high-performance languages like C++.

🛑 Problems I Faced & How I Fixed Them

Building this wasn't smooth sailing! Here are the main roadblocks I had to smash:
The pyaudio Nightmare: Getting speech_recognition to work on Windows was tough because installing pyaudio kept throwing errors. I had to figure out how to manually install the correct wheel file via the terminal to get my microphone recognized.

API Security: At first, I accidentally left my live News API key visible in the code. I had to learn how to remove it and replace it with a placeholder so people wouldn't steal my API limits when I pushed it to GitHub.

Microphone Lag & Timeouts: Jarvis would either cut me off too early or hang forever waiting for me to speak. I had to tweak the timeout=3 and phrase_time_limit= 5 settings in the listening loop so he only processed active commands without lagging out.

"Since this is one of my major projects, I’d love to hear your thoughts! Please drop a comment below with any suggestions, improvements, or tips on what I did right or what I could do better."

🤝 Let’s Collaborate!

Are you working on something exciting in AI, web development, blockchain, or Python? I’d love to connect and collaborate. You can reach me out in comment section or you can message me on github-https://github.com/Arish2008/CodeSphere

Check out my GitHub repo for the full code and documentation and also for more interesting projects like this. I'd love to hear your feedback or ideas for improvement!" -https://github.com/Arish2008/CodeSphere

Thanks for reading! Let me know in the comments what features I should add to Jarvis next! 🤖🔥

💻 Build your first blockchain today! Learn the basics, see it in action, and explore real-world uses. A fun and engaging read for anyone diving into blockchain tech! 🚀

Arish Sethi — Tue, 21 Jan 2025 17:46:35 +0000

Arish Sethi

Dec 1 '24

Building a Basic Blockchain in Python: My Journey and Key Takeaways!

4 min read

Building a Basic Blockchain in Python: My Journey and Key Takeaways!

Arish Sethi — Sun, 01 Dec 2024 13:56:05 +0000

**
Blockchain technology always fascinated me, so I decided to dive in and build my own mini blockchain using Python. Here's what I learned along the way**

Blockchain is a technology that allows for the secure, transparent, and permanent recording of data and transactions across a network.

My purpose of learning blockchain is to get a good knowledge of how the blocks work and what is the significance of POW (proof of work) and cryptography .As I am always intrested in blockchain because of its significant growth in the current few years.it also help me to improve my python skills.

KEY FEATURES OF BLOCKCHAIN:-

Chaining Blocks

*Each block in your blockchain contains:

*Data or transactions (e.g., sender, receiver, amount).

*A unique identifier called a hash, generated from the block's data.

*The hash of the previous block, linking the blocks together.

This ensures that the blocks are connected in a secure and sequential manner. If someone tries to change the data in one block, it would break the chain because the hash links wouldn’t match anymore.

** Proof of Work**

*To add a new block to the blockchain, your project likely includes a

*mining process, which involves solving a mathematical puzzle.
This puzzle ensures that:

*Adding a block takes some computational effort, making it hard to tamper with the chain.

*For example, the hash of a valid block must start with a specific number of zeroes (e.g., "0000").

This process makes the blockchain secure by requiring work to add blocks, preventing spam or malicious blocks.

Hashing

*Hashing converts the block’s data into a fixed-size string of characters (a hash).

*Your project likely uses a hashing algorithm (e.g., SHA-256) to generate this hash.

*The hash is unique to the block's data, like a digital fingerprint. Even a tiny change in the block’s data will produce a completely different hash.

For example:

Block data: {"amount": 5, "sender": "Alice", "receiver": "Bob"}
Hash: d2d2d2c6a8e9a6df13b54ff2c4da9ab9e2f4a8b9e8c1d6a9b4ff0d2c

API Testing Using Postman

Your blockchain likely includes API endpoints to interact with the chain.
Endpoints allow you to:

*Add transactions: Users can submit data (e.g., transactions).

*Mine new blocks: Solve the proof of work puzzle and add the block.

*View the blockchain: Retrieve the chain's current state to verify its contents.

Using Postman, you tested these endpoints to ensure they work as expected.

CHALLENGES I FACED AND HOW I OVERCOME THAT:-
my first challenge is to understand what these term means like hashing, proof of work and what is the chain in the block[which I explained it to you above.] so to overcome this problem I use ChatGPT and Gemini to get a handful of knowledge about blockchain key components AI helps me a lot.
My second problem is the implementation of proof of work as it is very tricky for me to get used to with proof of work [pow] algorithm but as I searched it in Google and asked from AI I started learning things and can apply that in my project. I set a condition where the hash must start with '0000', ensuring security.

I have used Postman for API testing there are some images which shows you how and what I have done
the first method is to create a new request (HTTP) in Postman.

step-2 after getting chain details we now have to create a new transaction.

we have to change get method to post and then give the request (provided in image),after this you have to go in headers section where in key column we have to write content-type and in value column, application/json.then switch to body choose raw format and set the format to json. In text box write the content given in the image.

step-3 mining a new block.

*code snippets for some important topics of blockchain:- *

making new block

    def new_block(self, proof, previous_hash=None):
        block = {
            'index': len(self.chain) + 1,
            'timestamp': time(),
            'transactions': self.current_transactions,
            'proof': proof,
            'previous_hash': previous_hash or self.hash(self.chain[-1] if self.chain else '0'),
        }

*making new transaction
*

    def new_transaction(self, sender, recipient, amount):
        # Add a new transaction to the list of transactions
        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })
        return self.last_block['index'] + 1  # Return the index of the block that will hold this transaction

for hashing

 @staticmethod
    def hash(block):
        # Creates a SHA-256 hash of a Block
        block_string = json.dumps(block, sort_keys=True).encode()
        return hashlib.sha256(block_string).hexdigest()

proof of work mechanism

def proof_of_work(self, last_proof):
        proof = 0
        while self.valid_proof(last_proof, proof) is False:
            proof += 1
        return proof

    @staticmethod 

def valid_proof(last_proof, proof):
        # Validates the Proof by checking if hash(last_proof, proof) has 4 leading zeroes
        guess = f"{last_proof}{proof}".encode()
        guess_hash = hashlib.sha256(guess).hexdigest()
        return guess_hash[:4] == "0000"

I’m always looking to improve and learn. If you have suggestions, ideas, or improvements, drop a comment below or create an issue on GitHub.

🤝 Let’s Collaborate!

Are you working on something exciting in AI, web development, blockchain, or Python? I’d love to connect and collaborate. You can reach me on:

Twitter: [@arish_seth]

Thank you for reading, and I can’t wait to hear your thoughts! 🚀