Building Your Own Simple Search Engine with Python

Have you ever wondered how search engines like Google work their magic? While building something as complex as Google is a monumental task, understanding the core principles isn’t! In this blog post, we’re going to embark on a fun and exciting journey: building a very simple search engine from scratch using Python. It won’t index the entire internet, but it will help you grasp the fundamental ideas behind how search engines find information.

This project is perfect for anyone curious about how data is processed, indexed, and retrieved. It’s a fantastic way to combine web scraping, text processing, and basic data structures into a practical application.

What is a Search Engine (Simply Put)?

At its heart, a search engine is a program that helps you find information on the internet (or within a specific set of documents). When you type a query, it quickly sifts through vast amounts of data to show you relevant results.

Think of it like an incredibly organized library. Instead of physically going through every book, you go to the index cards, find your topic, and it tells you exactly which books (and even which pages!) contain that information. Our simple search engine will do something similar, but for text data.

The Core Components of Our Simple Search Engine

Our miniature search engine will have three main stages:

1. Gathering Data (Web Scraping): We need content to search through. We’ll simulate fetching web pages and extracting their text.
   • Technical Term: Web Scraping
     This is the automated process of extracting information from websites. Instead of manually copying and pasting, a “scraper” program can visit a web page, read its content, and pull out specific pieces of data, like text, images, or links.
2. Processing and Indexing Data: Once we have the text, we need to process it and store it in a way that makes searching fast and efficient. This is where the “index” comes in.
   • Technical Term: Indexing
     Similar to the index at the back of a book, indexing in a search engine means creating a structured list of words and their locations (which documents they appear in). When you search, the engine doesn’t read every document again; it just consults this pre-built index.
3. Searching: Finally, we’ll build a function that takes your query, looks it up in our index, and returns the relevant documents.

Let’s get started!

Step 1: Gathering Data (Web Scraping Simulation)

For simplicity, instead of actually scraping live websites, we’ll create a list of “documents” (strings) that represent the content of different web pages. This allows us to focus on the indexing and searching logic without getting bogged down in complex web scraping edge cases.

However, it’s good to know how you would scrape if you were building a real one. You’d typically use libraries like requests to fetch the HTML content of a page and BeautifulSoup to parse that HTML and extract text.

Here’s a quick peek at what a scraping function might look like (without actual execution, as we’ll use our documents list):

import requests
from bs4 import BeautifulSoup

def simple_web_scraper(url):
    """
    Fetches the content of a URL and extracts all visible text.
    (This is a simplified example; we won't run it in our main program for now)
    """
    try:
        response = requests.get(url)
        response.raise_for_status() # Raise an exception for HTTP errors
        soup = BeautifulSoup(response.text, 'html.parser')

        # Remove script and style elements
        for script_or_style in soup(['script', 'style']):
            script_or_style.extract()

        # Get text
        text = soup.get_text()

        # Break into lines and remove whitespace
        lines = (line.strip() for line in text.splitlines())
        # Break multi-hyphenated words
        chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
        # Drop blank lines
        text = '\n'.join(chunk for chunk in chunks if chunk)
        return text
    except requests.exceptions.RequestException as e:
        print(f"Error fetching {url}: {e}")
        return None

For our simple engine, let’s define our “documents” directly:

documents = [
    "The quick brown fox jumps over the lazy dog.",
    "A dog is a man's best friend. Dogs are loyal.",
    "Cats are agile hunters, often playing with a string.",
    "The fox is known for its cunning and agility.",
    "Python is a versatile programming language used for web development, data analysis, and more."
]

print(f"Total documents to index: {len(documents)}")

Step 2: Processing and Indexing Data

This is the most crucial part of our search engine. We need to take the raw text from each document and transform it into an “inverted index.” An inverted index maps each unique word to a list of the documents where that word appears.

Here’s how we’ll build it:

1. Tokenization: We’ll break down each document’s text into individual words, called “tokens.”
   • Technical Term: Tokenization
     The process of breaking a stream of text into smaller units called “tokens” (words, numbers, punctuation, etc.). For our purpose, tokens will primarily be words.
2. Normalization: We’ll convert all words to lowercase and remove punctuation to ensure that “Dog,” “dog,” and “dog!” are all treated as the same word.
3. Building the Inverted Index: We’ll store these normalized words in a dictionary where the keys are the words and the values are sets of document IDs. Using a set automatically handles duplicate document IDs for a word within the same document.
   • Technical Term: Inverted Index
     A data structure that stores a mapping from content (like words) to its locations (like documents or web pages). It’s “inverted” because it points from words to documents, rather than from documents to words (like a traditional table of contents).

Let’s write the code for this:

import re

def build_inverted_index(docs):
    """
    Builds an inverted index from a list of documents.
    """
    inverted_index = {}
    for doc_id, doc_content in enumerate(docs):
        # Step 1 & 2: Tokenization and Normalization
        # Convert to lowercase and split by non-alphanumeric characters
        words = re.findall(r'\b\w+\b', doc_content.lower())

        for word in words:
            if word not in inverted_index:
                inverted_index[word] = set() # Use a set to store unique doc_ids
            inverted_index[word].add(doc_id)
    return inverted_index

inverted_index = build_inverted_index(documents)

print("\n--- Sample Inverted Index ---")
for word, doc_ids in list(inverted_index.items())[:5]: # Print first 5 items
    print(f"'{word}': {sorted(list(doc_ids))}")
print("...")

Explanation of the Indexing Code:

• enumerate(docs): This helps us get both the document content and a unique doc_id (0, 1, 2, …) for each document.
• re.findall(r'\b\w+\b', doc_content.lower()):
  • doc_content.lower(): Converts the entire document to lowercase.
  • re.findall(r'\b\w+\b', ...): This is a regular expression that finds all “word characters” (\w+) that are surrounded by “word boundaries” (\b). This effectively extracts words and ignores punctuation.
• inverted_index[word] = set(): If a word is encountered for the first time, we create a new empty set for it. Using a set is crucial because it automatically ensures that each doc_id is stored only once for any given word, even if the word appears multiple times within the same document.
• inverted_index[word].add(doc_id): We add the current doc_id to the set associated with the word.

Step 3: Implementing the Search Function

Now that we have our inverted_index, searching becomes straightforward. When a user types a query (e.g., “dog friend”), we:

1. Normalize the query: Convert it to lowercase and split it into individual search terms.
2. Look up each term: Find the list of document IDs for each term in our inverted_index.
3. Combine results: For a simple “AND” search (meaning all query terms must be present), we’ll find the intersection of the document ID sets for each term. This means only documents containing all specified words will be returned.

def search(query, index, docs):
    """
    Performs a simple 'AND' search on the inverted index.
    Returns the content of documents that contain all query terms.
    """
    query_terms = re.findall(r'\b\w+\b', query.lower())

    if not query_terms:
        return [] # No terms to search

    # Start with the document IDs for the first term
    # If the term is not in the index, its set is empty, and intersection will be empty
    results = index.get(query_terms[0], set()).copy() 

    # For subsequent terms, find the intersection of document IDs
    for term in query_terms[1:]:
        if not results: # If results are already empty, no need to check further
            break
        term_doc_ids = index.get(term, set()) # Get doc_ids for the current term
        results.intersection_update(term_doc_ids) # Keep only common doc_ids

    # Retrieve the actual document content for the found IDs
    found_documents_content = []
    for doc_id in sorted(list(results)):
        if 0 <= doc_id < len(docs): # Ensure doc_id is valid
            found_documents_content.append(f"Document ID {doc_id}: {docs[doc_id]}")

    return found_documents_content

print("\n--- Testing Our Search Engine ---")

queries = [
    "dog",
    "lazy dog",
    "python language",
    "fox agile",
    "programming friend", # Expect no results
    "friend",
    "cats"
]

for q in queries:
    print(f"\nSearching for: '{q}'")
    search_results = search(q, inverted_index, documents)
    if search_results:
        for result in search_results:
            print(f"- {result}")
    else:
        print("  No matching documents found.")

Limitations and Next Steps

Congratulations! You’ve just built a very basic but functional search engine. It demonstrates the core principles of how search engines work. However, our simple engine has some limitations:

• No Ranking: It just tells you if a document contains the words, but not which document is most relevant (e.g., based on how many times the word appears, or its position). Real search engines use complex ranking algorithms (like TF-IDF or PageRank).
• Simple “AND” Search: It only returns documents that contain all query words. It doesn’t handle “OR” searches, phrases (like "quick brown fox"), or misspelled words.
• No Stop Word Removal: Common words like “the,” “a,” “is” (called stop words) are indexed. For larger datasets, these can be filtered out to save space and improve search relevance.
• Small Scale: It’s only working on a handful of documents in memory. Real search engines deal with billions of web pages.
• No Persistent Storage: If you close the program, the index is lost. A real search engine would store its index in a database or specialized data store.

Ideas for improvement if you want to take it further:

• Implement TF-IDF: A simple ranking algorithm that helps identify how important a word is to a document in a collection.
• Handle more complex queries: Allow for “OR” queries, phrase searching, and exclusion of words.
• Add a web interface: Build a simple user interface using Flask or Django to make it accessible in a browser.
• Crawl actual websites: Modify the scraping part to systematically visit links and build a larger index.
• Error Handling and Robustness: Improve how it handles malformed HTML, network errors, etc.

Conclusion

Building this simple search engine is a fantastic way to demystify how these powerful tools work. You’ve learned about web scraping (conceptually), text processing, creating an inverted index, and performing basic searches. This project truly showcases the power of Python for data manipulation and problem-solving. Keep experimenting, and who knows, maybe you’ll contribute to the next generation of information retrieval!