A free chatbot that searches the web and remembers each user

What you get

One Python script, chat.py, that you run in the terminal. It asks for a user id once. Then, for each message you type, it does four things:

Looks up what Mem0 already remembers about this user.
Searches the web with Tavily for your message.
Sends the memories and search results to Gemini 3.8 Flash as context, and prints the reply.
Saves your message to Mem0, so the next turn knows more about this user.

If one turn fails, the script prints a short message and waits for your next message instead of stopping. If Gemini's free quota is used up, it says so, with the wait time Google gives. Type quit to stop. All three services have a free plan you can test this on.

Before you start

Set up each piece first, in this order. Each one has its own integration and its own test you can run alone.

Google Gemini. Needs GEMINI_API_KEY. Create a key in Google AI Studio at https://aistudio.google.com/apikey. Google's billing page says new accounts start on the free tier, and only higher tiers need a linked billing account. Google's pricing page lists gemini-3.8-flash as "Free of charge" on the free tier. The same page marks free-tier content as used to improve Google's products, and paid-tier content as not used. Do not send anything private while testing on the free tier.
Tavily web search (Python version). Needs TAVILY_API_KEY. Get one at https://app.tavily.com. Tavily's docs say you get 1,000 free API credits every month, with no credit card required. A basic search costs 1 credit.
Mem0 memory. Needs MEM0_API_KEY. Create it at https://app.mem0.ai/dashboard/settings?tab=api-keys&subtab=configuration. Mem0's pricing page lists a free Hobby plan with 10,000 add requests and 1,000 retrieval requests a month. Each message in this chat uses one of each.

Mem0 needs Python 3.10 or newer.

Put all three keys in a .env file next to chat.py. The script loads that file itself. If you saved the keys on this computer with npx wirestack keys add <tool>, run npx wirestack keys fill in the project folder and it writes them into .env. Or paste them in by hand:

Text

GEMINI_API_KEY=your-gemini-key
TAVILY_API_KEY=tvly-YOUR_API_KEY
MEM0_API_KEY=your-mem0-key

Keep .env out of git.

As an alternative, you can set the keys in the terminal you will run the script from. On macOS or Linux:

Shell

export GEMINI_API_KEY="your-gemini-key"
export TAVILY_API_KEY="tvly-YOUR_API_KEY"
export MEM0_API_KEY="your-mem0-key"

On Windows PowerShell:

powershell

$env:GEMINI_API_KEY="your-gemini-key"
$env:TAVILY_API_KEY="tvly-YOUR_API_KEY"
$env:MEM0_API_KEY="your-mem0-key"

Google's docs say the client also reads GOOGLE_API_KEY, and that it wins if both are set. If you have an old GOOGLE_API_KEY set, remove it or set it to the same key.

Connect them

Install the packages. These are the latest versions on PyPI today:

Shell

pip install google-genai==2.32.0 tavily-python==0.7.8 mem0ai==2.2.1 python-dotenv==1.2.4

On Windows you may need py -m pip install ... instead.

Create chat.py:

Python

import os
import sys

from dotenv import load_dotenv
from google import genai
from google.genai import types
from mem0 import MemoryClient
from tavily import TavilyClient

load_dotenv()
sys.stdout.reconfigure(encoding="utf-8")

# Timeout is in milliseconds: 120_000 is 120 seconds, for each HTTP attempt.
# retry_options: the SDK retries only a 503 (Gemini busy), and only once.
# A 429 (quota used up) is not retried, so it fails at once instead of
# waiting for hours.
gemini = genai.Client(
    http_options=types.HttpOptions(
        timeout=120_000,
        retry_options=types.HttpRetryOptions(attempts=1, http_status_codes=[503]),
    )
)
tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
memory = MemoryClient()


def web_search(query):
    response = tavily_client.search(
        query,
        max_results=5,
        include_answer=True,
    )
    return {
        "answer": response.get("answer"),
        "sources": [
            {"title": r["title"], "url": r["url"], "content": r["content"]}
            for r in response["results"]
        ],
    }


def is_malformed_tool_call(error):
    # Gemini's 400 error with code "malformed_tool_call" asks you to retry.
    body = getattr(error, "body", None)
    if getattr(error, "status_code", None) != 400 or not isinstance(body, dict):
        return False
    details = body.get("error")
    return isinstance(details, dict) and details.get("code") == "malformed_tool_call"


class GeminiQuotaError(Exception):
    def __init__(self, minutes):
        super().__init__("Gemini quota used up")
        self.minutes = minutes


def quota_wait_minutes(error):
    # Gemini's 429 reply has a Retry-After header: the wait in seconds.
    response = getattr(error, "response", None)
    headers = getattr(response, "headers", None) or {}
    try:
        seconds = float(headers.get("retry-after", ""))
    except ValueError:
        return None
    return max(1, round(seconds / 60))


def ask_gemini(system, message):
    for attempt in range(3):  # the first try plus up to 2 retries
        try:
            interaction = gemini.interactions.create(
                model="gemini-3.8-flash",
                system_instruction=system,
                input=message,
            )
            return interaction.output_text
        except Exception as error:
            if attempt < 2 and is_malformed_tool_call(error):
                print("(Gemini sent a broken reply. Trying again.)")
                continue
            if getattr(error, "status_code", None) == 429:
                raise GeminiQuotaError(quota_wait_minutes(error)) from error
            raise


user_id = input("User id: ").strip()
print('Type a message. Type "quit" to stop.')

while True:
    message = input("\nYou: ").strip()
    if message.lower() == "quit":
        break
    if not message:
        continue

    try:
        # 1. What do we already know about this user?
        found = memory.search(message, filters={"user_id": user_id})
        memories = [m["memory"] for m in found["results"]]

        # 2. What does the web say?
        search = web_search(message)

        # 3. Put both into the system instruction.
        system = (
            "You are a helpful assistant.\n\n"
            "What you know about this user:\n"
            + ("\n".join(f"- {m}" for m in memories) or "- Nothing yet.")
            + "\n\nWeb search results. Cite the URLs you use:\n"
            + f"Summary: {search['answer']}\n"
            + "\n".join(
                f"- {s['title']} ({s['url']}): {s['content']}" for s in search["sources"]
            )
        )

        reply = ask_gemini(system, message)
        print(f"\nBot: {reply}")

        # 4. Save only the user's message, so Mem0 learns facts about the user.
        memory.add(
            [{"role": "user", "content": message}],
            user_id=user_id,
        )
    except GeminiQuotaError as error:
        wait = f" (Google said: about {error.minutes} minutes)" if error.minutes else ""
        print(f"\nGemini's free quota is used up for now. Try again later{wait}.")
    except Exception as error:
        print(f"\nThat turn failed ({type(error).__name__}). Try again, or type quit.")

Run it:

Shell

python chat.py

On Windows the command is usually py chat.py.

What each part does:

Keys and output. load_dotenv() reads your keys from .env before any client is created. sys.stdout.reconfigure(encoding="utf-8") makes printed replies UTF-8, so characters like dashes do not come out garbled, or crash the script, on Windows.
Clients. genai.Client() reads GEMINI_API_KEY, as in the Gemini piece. HttpOptions(timeout=120_000) stops a Gemini request after 120 seconds; the SDK takes the timeout in milliseconds. The limit applies to each HTTP attempt, not to the SDK's waits between attempts. That is why retry_options is set too: HttpRetryOptions(attempts=1, http_status_codes=[503]) lets the SDK retry only a 503 (Gemini busy), once. Without it, the SDK retries a 429 by itself and waits the full time Google asks for (in testing, almost 8 hours) before each retry, so the chat froze with no output. TavilyClient gets TAVILY_API_KEY passed in, as in the Tavily piece. MemoryClient() reads MEM0_API_KEY, as in the Mem0 piece.
User id. Asked once at the start. Every Mem0 read and write uses it, so each user gets their own memories.
with returns a list. The code keeps only the text of each item.

Each turn is sent to Gemini on its own. Gemini does not see earlier turns directly. It only sees what Mem0 has saved about the user. Google's docs show previous_interaction_id for chaining turns, but this integration does not use it.

Test it

Run python chat.py (or py chat.py on Windows). At the User id: prompt, type user123.

Tell it something about yourself:

Text

You: I am a vegetarian. Any news about plant-based protein this year?

You should see a reply that uses web results, with URLs.

Wait a few seconds, then ask something that needs the memory:

Text

You: Suggest a quick dinner for me.

The reply should take your diet into account. Type quit. Run the script again with a different user id, such as user456, and ask the same dinner question. This time the reply should not know your diet.

In testing, the free tier's Gemini quota ran out after one round of tests (about 10 to 15 calls). If you see "Gemini's free quota is used up for now", the chat is working as meant: wait the time it shows, or use a paid-tier key.

Not confirmed

The combined chat.py was run end to end once by hand and worked: the memory carried across turns, and each user had separate memories. Before the fixes on this page, it failed 2 of 2 automated runs. The next version was tested with a fake Gemini key: each failed turn printed its message and the chat kept going. A full run was blocked because the free quota was used up, and that version froze for hours on the 429 (fixed on this page with retry_options). This version, with the quota message, has not been run yet. The malformed_tool_call retry, the UTF-8 output, and saving only the user's message have not been checked in a run either.
In testing, Gemini answered a plain text request with HTTP 400 and code malformed_tool_call, although no tools were sent. The cause is unknown. It may be set off by the web search text in the system instruction, but that was not confirmed.
The retry check reads status_code and body from the error. Both come from the google-genai 2.32.0 source on GitHub (google/genai/_gaos/lib/compat_errors.py), not from Google's docs. In that version the error class (BadRequestError) only lives under a private module path, so the script checks those two values instead of importing the class. If a later SDK version changes them, the retry stops working, but the per-turn error handling still keeps the chat going.
Gemini free-tier calls were slow in an earlier test: 100 to 190 seconds each, and one hung for more than 5 minutes. They may have been the SDK waiting between 429 retries as the quota ran low, but that is not confirmed. The 120-second timeout and its milliseconds unit come from the google-genai 2.32.0 source (HttpOptions.timeout). Testing showed it applies to each HTTP attempt, and the SDK's waits between retries are not covered by it.
The retry setting comes from the google-genai 2.32.0 source, not from Google's docs pages. HttpRetryOptions and HttpOptions.retry_options are public types, but how they reach client.interactions was read in google/genai/_gaos/google_genai.py (_translate_retry_config). In that version, attempts becomes the number of retries for Interactions calls, so attempts=1 gives one retry, although the field's own description says 1 means no retries. attempts=0 does not turn retries off there either: the SDK changes 0 to 1 when the client is created (google/genai/_api_client.py, retry_args). There is no per-call retry setting on interactions.create in 2.32.0. If a later SDK version changes this, the 429 may be retried again.

A free chatbot that searches the web and remembers each user

Your keys

How the pieces connect

What you get

Before you start

Connect them

Test it

Not confirmed