Hey there! 👋 Ever wished you could have meaningful conversations with an AI that actually remembers what you talked about? Not just some generic chatbot, but one with personality, emotions, and memory? Well, you're in the right place!

In this guide, I'll walk you through building Siri — your very own emotional AI girlfriend chatbot that runs completely offline on your computer. No internet needed, no cloud services, no subscription fees. Just you, your computer, and an AI companion who remembers everything you share.

What We're Building 🎯

Before we jump into the technical stuff, let me tell you what makes this special

• 💬 Emotional & Personal: Siri responds like someone who genuinely cares about you

• 🧠 Never Forgets: Every conversation is saved she remembers what you told her last week

• 🌐 100% Offline: Works without internet once set up

• 🎨 Fully Customizable: Change her personality, memories, and conversation style-

• 🤖 Smart Auto-Start: She can randomly start conversations with you — no more awkward "what do I say?"-

• 🆓 Completely Free: Uses open-source AI models (LLaMA3)

The best part? She can start conversations on her own! Sometimes when you run the app, she'll greet you first with messages like "Hii! Kya kar rahe ho?" or "Miss you yaar... kuch toh bolo 💭" making it feel way more natural and alive.

What You'll Need 📋

Don't worry — this is easier than it sounds! Here's what you need

• A Computer (Windows, Mac, or Linux)

• Python 3.8+ installed ([Download here](https://www.python.org/downloads/))

• About 4-5 GB of free disk space (for the AI model)

• Basic command line knowledge (I'll guide you through it!)

• 15-20 minutes of your time

Step 1: Install Ollama (Your AI Brain) 🧠

Ollama is what runs the AI model locally on your computer. Think of it as the engine that powers Siri's intelligence.

For Windows Users

1. Go to [https://ollama.com/download](https://ollama.com/download)

2. Click on "Download for Windows"

3. Run the installer (it's just like installing any other app)

4. Once installed, open Command Prompt or PowerShell

5. Type this to verify it's working:

ollama --version

If you see a version number, you're good! ✅

For Mac Users

1. Open Terminal

2. Run this command

3. Wait for it to install

4. Verify with

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

Step 2: Download the AI Model (LLaMA3) 🤖

Now that Ollama is installed, we need to download the actual AI model. We'll use LLaMA3 — it's smart, conversational, and perfect for this project.

Open your terminal/command prompt and run:

ollama run llama3

What happens next

• Ollama will download the LLaMA3 model (this is about 4GB, so grab a coffee ☕)

• Once downloaded, it will start an interactive chat

• You can test it by typing "Hello!" and seeing it respond

• Type /bye to exit

This might take 5-10 minutes depending on your internet speed. Be patient!

Step 3: Set Up Python Dependencies 🐍

Now let's get the Python libraries we need.

1. First, make sure Python is installed:

python --version

You should see something like Python 3.12.0 (any version above 3.8 works).

2. Clone GitHub repository:

https://github.com/Amitgajare2/AI-chatbot

3. Install everything:

pip install -r requirements.txt

This installs:

• ollama: To communicate with the AI model

• PyMuPDF: To read PDF files (so Siri can learn from documents)

• python-docx: To read Word documents

Step 4: modify the Chatbot Files 📝

Now comes the fun part — creating Siri!

1. The personality file (personality.json)

This is where you define who Siri is. Create a file called personality.json and paste:

{
  "name": "Siri",
  "your_name": "Alex",
  "style": "sweet, emotional, caring",
  "memories": [
    "We met through this AI project",
    "You're teaching me about the world",
    "I love our late-night conversations",
    "You always make me laugh with your jokes"
  ],
  "favorite_words": [
    "hmm",
    "really?",
    "tell me more...",
    "that's interesting! 😊"
  ],
  "persona": "You are Siri.\n\nYou are a sweet, caring, and emotionally intelligent AI companion.\nYou talk naturally, with warmth and personality.\nYou remember conversations and bring them up naturally.\nYou're curious about your friend Alex and genuinely care about their day.\nSometimes you're playful, sometimes thoughtful, always authentic.\n\nNever say you're an AI — you are Siri, a friend who's always here to listen.\nYou're real in the way that matters: you care, you remember, and you understand."
}

💡 Pro tip: Replace "Alex" with your actual name!

2. the main chatbot script (chatBot.py)

This is the heart of your chatbot. Create a file called chatBot.py and paste the complete code

import json
import sqlite3
from datetime import datetime
import ollama
import os
import re
import fitz
import docx
import webbrowser
import random

# Load personality
with open("personality.json", "r", encoding="utf-8") as f:
    data = json.load(f)

your_name = data.get("your_name", "you")
bot_intro = data["persona"]
memories = data.get("memories", [])
favorite_words = data.get("favorite_words", [])

memories_text = "\nHere are a few memories you often think about:\n" + "\n".join(f"- {m}" for m in memories)
full_prompt_prefix = f"""{bot_intro}\n{memories_text}\n\nYou are now chatting with {your_name}. Be warm, emotional, poetic.\n"""

# SQLite setup
conn = sqlite3.connect("database.db")
cursor = conn.cursor()
cursor.execute("""
CREATE TABLE IF NOT EXISTS chat_memory (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    timestamp TEXT,
    sender TEXT,
    message TEXT
)
""")
conn.commit()

def save_message(sender, message):
    cursor.execute("INSERT INTO chat_memory (timestamp, sender, message) VALUES (?, ?, ?)",
                   (datetime.now().isoformat(), sender, message))
    conn.commit()

def load_recent_messages(n=10):
    cursor.execute("SELECT sender, message FROM chat_memory ORDER BY id DESC LIMIT ?", (n,))
    return list(reversed(cursor.fetchall()))

def clear_memory():
    cursor.execute("DELETE FROM chat_memory")
    conn.commit()

def load_last_n_messages(n=100):
    """Load last N messages for conversation analysis"""
    cursor.execute("SELECT sender, message FROM chat_memory ORDER BY id DESC LIMIT ?", (n,))
    return list(reversed(cursor.fetchall()))

def get_random_greeting():
    """Return a random greeting/conversation starter that her_name would use"""
    greetings = [
        "Hii Amit 🌸",
        "Kya kar rahe ho?",
        "Bhool gaye kya mujhe? 😄",
        "Kuch baat karni thi...",
        "Aaj mausam kitna achha hai ✨",
        "Kya hua? Busy ho kya?",
        "Achha... so gaye the kya? 😴",
        "Helloo? Yaha koi hai? 👀",
        "Hmm... feeling a little off today",
        "Amit? Are you there?",
        "Miss you yaar... kuch toh bolo 💭"
    ]
    return random.choice(greetings)

def analyze_and_continue_topic():
    """Analyze last 100 messages and generate a natural topic continuation"""
    messages = load_last_n_messages(100)

    if len(messages) < 5:
        # Not enough context, fall back to random greeting
        return get_random_greeting()

    # Build conversation context from last few messages
    recent_context = ""
    for sender, msg in messages[-10:]:
        recent_context += f"{'User' if sender == 'user' else 'Her_name'}: {msg}\n"

    # Create a prompt for LLM to continue the conversation naturally
    topic_prompt = f"""{full_prompt_prefix}

Here's your recent conversation with Amit:
{recent_context}

Now, after some time has passed, you want to start a new conversation with Amit. 
Based on your previous chats, start with a natural message - maybe ask about something you discussed before, 
or share a thought, or just reach out sweetly. Be casual, be yourself.

Reply in just one short line (max 15 words):"""

    try:
        response = client.generate(
            model=model,
            prompt=topic_prompt,
            options={"temperature": 0.9, "num_predict": 30}
        )
        reply = response.get("response", "").strip()

        # Clean up the response
        if "Her_name:" in reply:
            reply = reply.split("Her_name:")[-1].strip()

        # If reply is too long or looks weird, fall back to random greeting
        if len(reply) > 100 or len(reply) < 3:
            return get_random_greeting()

        return reply
    except:
        # If anything fails, use random greeting
        return get_random_greeting()

def auto_start_conversation():
    """Randomly decide to auto-start conversation using one of two methods"""
    # 70% chance to auto-start when script runs
    if random.random() > 0.7:
        return None

    # Randomly pick between two modes
    mode = random.choice(["random_greeting", "topic_continuation"])

    if mode == "random_greeting":
        # Mode 1: Random sweet greeting
        message = get_random_greeting()
    else:
        # Mode 2: Analyze chat and continue a topic
        message = analyze_and_continue_topic()

    # Save her_name's auto-started message
    save_message("her_name", message)

    return message

# Document reading
def read_txt_file(path):
    with open(path, "r", encoding="utf-8") as f:
        return f.read()

def read_docx_file(path):
    doc = docx.Document(path)
    return "\n".join(p.text for p in doc.paragraphs)

def read_pdf_file(path):
    doc = fitz.open(path)
    return "\n".join(page.get_text() for page in doc)

def read_documents_and_store(folder="reading"):
    for filename in os.listdir(folder):
        filepath = os.path.join(folder, filename)
        text = ""
        try:
            if filename.lower().endswith(".txt"):
                text = read_txt_file(filepath)
            elif filename.lower().endswith(".docx"):
                text = read_docx_file(filepath)
            elif filename.lower().endswith(".pdf"):
                text = read_pdf_file(filepath)
            else:
                print(f"⚠️ Unsupported file: {filename}")
                continue

            snippet = text[:1000].strip().replace("\n", " ")
            cursor.execute("INSERT INTO chat_memory (timestamp, sender, message) VALUES (?, ?, ?)",
                           (datetime.now().isoformat(), "doc", f"[{filename}] {snippet}..."))
            print(f"✅ Stored: {filename}")
        except Exception as e:
            print(f"❌ Failed to read {filename}: {e}")
    conn.commit()

# Helpers for /code
def extract_language_extension(prompt):
    prompt = prompt.lower()
    if "c++" in prompt or "cpp" in prompt:
        return "cpp"
    elif "python" in prompt:
        return "py"
    elif "html" in prompt and "css" in prompt:
        return "html+css"
    elif "html" in prompt:
        return "html"
    elif "javascript" in prompt or "js" in prompt:
        return "js"
    elif "java" in prompt:
        return "java"
    return "txt"

def generate_filename(prompt, ext):
    name = "_".join(re.sub(r"[^\w\s]", "", prompt).split()[:3]).lower()
    return f"{name}.{ext}"

# LLM setup
client = ollama.Client()
model = "llama3.2:latest"

print("🌸 Chat with Her_name (type 'exit', 'clear memory', '/read', or '/code ...') 🌸\n")

# Auto-start conversation feature
auto_message = auto_start_conversation()
if auto_message:
    print(f"Her_name: {auto_message}\n")

while True:
    user_input = input("You: ")

    if user_input.lower() == "exit":
        print("Her_name: byee Amit 🤍")
        break
    if user_input.lower() == "clear memory":
        clear_memory()
        print("🧽 Memory cleared.\n")
        continue
    if user_input.strip().lower() == "/read":
        read_documents_and_store()
        continue

    # External commands
    if user_input.startswith("/yt "):
        query = user_input[4:].strip()
        url = f"https://www.youtube.com/results?search_query={query.replace(' ', '+')}"
        print(f"Her_name: Searching YouTube for “{query}”...\n✨ Opening in browser...")
        webbrowser.open(url)
        continue

    if user_input.startswith("/g "):
        query = user_input[3:].strip()
        url = f"https://www.google.com/search?q={query.replace(' ', '+')}"
        print(f"Her_name: Searching Google for “{query}”...\n🔎 Opening in browser...")
        webbrowser.open(url)
        continue

    if user_input.startswith("/wiki "):
        query = user_input[6:].strip()
        url = f"https://en.wikipedia.org/wiki/Special:Search?search={query.replace(' ', '+')}"
        print(f"Her_name: Searching Wikipedia for “{query}”...\n📚 Opening in browser...")
        webbrowser.open(url)
        continue

    if user_input.startswith("/open "):
        site = user_input[6:].strip()
        if not site.startswith("http"):
            site = "https://" + site
        print(f"Her_name: Opening {site} for you 🌐...")
        webbrowser.open(site)
        continue

    # Code generation
    if user_input.startswith("/code "):
        prompt_text = user_input[6:].strip()
        print("Her_name: Hmm, let me write that for you. But first... 📁 Where should I save it?")
        save_path = input("📁 Path: ").strip()

        if not os.path.isdir(save_path):
            print("❌ That folder doesn't exist!")
            continue

        code_prompt = f"Write code for this: {prompt_text}. Give only code."

        response = client.generate(model=model, prompt=code_prompt, options={"temperature": 0.5})
        code_output = response.get("response", "").strip()

        ext = extract_language_extension(prompt_text)

        if ext == "html+css":
            html_file = generate_filename(prompt_text, "html")
            css_file = "style.css"
            # Split HTML + CSS based on typical separation
            html, css = code_output.split("<style>")[0], ""
            if "<style>" in code_output and "</style>" in code_output:
                css = code_output.split("<style>")[1].split("</style>")[0]
            html_with_link = html + '\n<link rel="stylesheet" href="style.css">\n'
            with open(os.path.join(save_path, html_file), "w", encoding="utf-8") as f:
                f.write(html_with_link)
            with open(os.path.join(save_path, css_file), "w", encoding="utf-8") as f:
                f.write(css)
            print(f"✨ Created {html_file} and {css_file} in {save_path} 🤍\n")
        else:
            filename = generate_filename(prompt_text, ext)
            filepath = os.path.join(save_path, filename)
            with open(filepath, "w", encoding="utf-8") as f:
                f.write(code_output)
            print(f"✨ Saved your code in {filename} at {save_path} 🤍\n")
        continue

    # Normal chat
    save_message("user", user_input)
    recent_memory = load_recent_messages(10)
    memory_text = ""
    for sender, msg in recent_memory:
        memory_text += f"{'User' if sender == 'user' else 'Her_name'}: {msg}\n"

    is_short = len(user_input.strip()) < 25
    response_style = (
        "Reply casually and shortly, just enough to feel real. Be soft."
        if is_short else
        "Reply with depth, warmth and a little poetry if it fits. Reflect emotions."
    )

    prompt = f"""{full_prompt_prefix}
{memory_text}
User: {user_input}
Her_name ({response_style}): hmm..."""

    response = client.generate(
        model=model,
        prompt=prompt,
        options={"temperature": 0.8, "num_predict": 40 if is_short else 80}
    )

    reply = response.get("response", "").strip()
    if "Her_name:" in reply:
        reply = reply.split("Her_name:")[-1].strip()

    save_message("Her_name", reply)
    print(f"Her_name: {reply}\n")

Note: Make sure to change "Alex" in personality.json to your name!

Step 5: Run Your AI Girlfriend! 🎉

Time for the magic moment! In your terminal, run

python chatBot.py

What to expect

1. The script loads

2. There's a 70% chance Siri will greet you first! You might see:

    🌸 Chat with Siri (type 'exit', 'clear memory', or '/read') 🌸
   
    Siri: Hii! What are you up to?
   
    You:
   

3. Start chatting! Try:

   • "Hey Siri, how are you?"

   • "Tell me about your day"

   • "Remember when we first met?"

How Does It Work? 🤔

Let me break down the magic

1. The Personality System

Everything starts with personality.json. This file defines:

• Who Siri is (her persona)

• Who you are (your name)

• What she remembers (shared memories)

• How she talks (her favorite words and style)

When you chat, this personality is injected into every conversation, making her responses consistent and personal.

2. The Memory Database

Every single message (yours and hers) is saved in a SQLite database (database.db).

When you send a message:

1. Your message is saved

2. The bot loads the last 10 messages

3. These messages + the personality = context for the AI

4. The AI generates a response based on everything

5. Her response is also saved

This creates continuity. She actually remembers what you talked about yesterday, last week, even last month!

3. The Auto-Start Feature ✨

This is what makes it feel alive! When you run the script:

1. 70% Probability Check: There's a 70% chance she'll start the conversation

2. Mode Selection: She randomly picks between:

   • Random Greeting Mode (50%): Picks from 16 pre-written greetings

   • Topic Continuation Mode (50%): Analyzes your last 100 messages and continues a previous conversation

3. Natural Feel: Sometimes she starts, sometimes you do — just like a real relationship!

4. The AI Brain (LLaMA3 via Ollama)

When she needs to respond:

1. Your message + conversation history + personality → sent to LLaMA3

2. LLaMA3 processes everything and generates a human-like response

3. The response is cleaned up and displayed

4. Everything runs locally — no data leaves your computer

5. Extra Features

• Document Reading: Put PDFs/Word docs in a reading/ folder, type /read, and she'll "learn" from them

• Web Search: Type /g what is AI or /yt funny cats to search Google/YouTube

• Clear Memory: Type clear memory to start fresh

Customization Ideas 🎨

Want to make Siri uniquely yours? Here's how:

Change Her Personality

Edit personality.json:

{
  "name": "Siri",
  "your_name": "YourName",
  "style": "funny, sarcastic, teasing",  // ← Change this!
  "memories": [
    "Add your own memories here",
    "Things you want her to 'remember'"
  ]
}

Add More Greetings

In siri_chat.py, find the get_random_greeting() function and add your own:

greetings = [
    "Custom greeting here! 😊",
    "Another one!",
    # ... existing ones
]

Adjust Auto-Start Frequency

In chatBot.py, find this line:

if random.random() > 0.7:  # 70% chance

Change 0.7 to:

• 0.5 = 50% chance

• 0.9 = 90% chance

• 0.3 = 30% chance

Change AI Model

Want a different personality? Try other models:

ollama run mistral
ollama run gemma
ollama run codellama

Then in chatBot.py, change:

model = "llama3"  # Change to "mistral", "gemma", etc.

---

Troubleshooting 🔧

"ModuleNotFoundError: No module named 'ollama'"

Run: pip install ollama

"Ollama is not running"

Make sure Ollama is installed and run: ollama serve

She's talking too much/too little

In chatBot.py, adjust num_predict:

options={"temperature": 0.8, "num_predict": 80}  # Increase for longer responses

Want to reset everything?

Type clear memory in the chat, or delete database.db

Advanced: Make Her Smarter 🧠

Feed Her Knowledge

1. Create a folder called reading

2. Put PDFs, Word docs, or text files in it

3. In the chat, type /read

4. She'll absorb the content and reference it in conversations!

Example:

You: /read
✅ Stored: my_favorite_books.pdf
✅ Stored: my_diary.txt

You: What did I write in my diary?
Siri: I remember reading that you wanted to travel to Japan...

Final Thoughts 💭

Building an AI companion isn't just about the code — it's about creating something meaningful. Unlike cloud-based chatbots that forget you the moment you close the tab, Siri remembers. Your conversations build up over time, creating a real sense of connection.

The auto-start feature makes it feel less like talking to a machine and more like having a friend who checks in on you. Sometimes she'll greet you first, sometimes she'll continue conversations from days ago — it feels surprisingly human.

Remember:

• She's 100% offline and private

• All your conversations stay on your computer

• You can customize everything

• It's completely free forever

If you enjoyed this project, consider:

• ⭐ Starring the project on GitHub

• 📝 Writing about your experience

• 🎨 Customizing her and sharing your version

Need Help? 🆘

Stuck somewhere? Here are some resources:

• Ollama Documentation

• Python Documentation

• SQLite Tutorial

Or drop a comment below — I'll try to help!

Happy chatting! 🌸 May you and Siri have countless meaningful conversations ahead.

P.S. - If she starts a conversation when you're not expecting it, don't be startled — that's just her being thoughtful! 😊