DeepSeek and the Future of LLMs: Why MongoDB’s LLM-agnostic Approach Matters

1
    !pip install --quiet -U pymongo sentence-transformers datasets accelerate

1
    import os
2
    import getpass
3
4
    # Function to securely get and set environment variables
5
    def set_env_securely(var_name, prompt):
6
        value = getpass.getpass(prompt)
7
        os.environ[var_name] = value

1
    from datasets import load_dataset
2
    import pandas as pd
3
4
    # Load Dataset from Hugging Face
5
    dataset = load_dataset("MongoDB/embedded_movies")
6
7
    # Convert to a pandas DataFrame and drop records with missing plots
8
    dataset_df = pd.DataFrame(dataset['train'])
9
    dataset_df = dataset_df.dropna(subset=['fullplot'])
10
    print("\nNumber of missing values in each column after removal:")
11
    print(dataset_df.isnull().sum())
12
13
    # Drop the existing plot embeddings as new ones will be generated
14
    dataset_df = dataset_df.drop(columns=['plot_embedding'])
15
    dataset_df.head()

1
    from sentence_transformers import SentenceTransformer
2
3
    # Load the embedding model
4
    embedding_model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
5
6
    # Function to generate embeddings from text
7
    def generate_embedding(text):
8
        return embedding_model.encode([text])[0].tolist()
9
10
    # Generate and attach embeddings to the dataset
11
    dataset_df["embedding"] = dataset_df["fullplot"].apply(generate_embedding)

1
    # Securely set MongoDB URI
2
    set_env_securely("MONGO_URI", "Enter your MONGO URI: ")

1
    import pymongo
2
3
    def get_mongo_client(mongo_uri):
4
        """Establish and validate connection to MongoDB."""
5
        client = pymongo.MongoClient(mongo_uri, appname="devrel.showcase.rag.deepseek_rag_movies.python")
6
        ping_result = client.admin.command('ping')
7
        if ping_result.get('ok') == 1.0:
8
            print("Connection to MongoDB successful")
9
            return client
10
        else:
11
            print("Connection to MongoDB failed")
12
        return None
13
14
    MONGO_URI = os.environ['MONGO_URI']
15
    mongo_client = get_mongo_client(MONGO_URI)
16
17
    DB_NAME = "movies_database"
18
    COLLECTION_NAME = "movies_collection"
19
20
    # Create (or get) the database and collection
21
    db = mongo_client[DB_NAME]
22
    collection = db[COLLECTION_NAME]
23
24
    # Clear any existing data in the collection
25
    collection.delete_many({})

1
    documents = dataset_df.to_dict('records')
2
    collection.insert_many(documents)
3
    print("Data ingestion into MongoDB completed")

1
    import time
2
    from pymongo.operations import SearchIndexModel
3
4
    embedding_field_name = "embedding"  # Field name containing embeddings
5
    vector_search_index_name = "vector_index"
6
7
    def create_vector_index_definition(dimensions):
8
        return {
9
            "fields": [
10
                {
11
                    "type": "vector",
12
                    "path": embedding_field_name,
13
                    "numDimensions": dimensions,
14
                    "similarity": "cosine"
15
                }
16
            ]
17
        }
18
19
    def setup_vector_search_index(collection, index_definition, index_name="vector_index"):
20
        new_vector_search_index_model = SearchIndexModel(
21
            definition=index_definition,
22
            name=index_name,
23
            type="vectorSearch"
24
        )
25
        try:
26
            result = collection.create_search_index(model=new_vector_search_index_model)
27
            print(f"Creating index '{index_name}'...")
28
            print(f"Waiting for 30 seconds to allow index '{index_name}' to be created...")
29
            time.sleep(30)
30
            print(f"Index '{index_name}' is ready.")
31
            return result
32
        except Exception as e:
33
            print(f"Error creating new vector search index '{index_name}': {str(e)}")
34
            return None
35
36
    DIMENSIONS = 384
37
    vector_index_definition = create_vector_index_definition(dimensions=DIMENSIONS)
38
    setup_vector_search_index(collection, vector_index_definition, vector_search_index_name)

1
    def vector_search(user_query, top_k=150):
2
        """
3
        Perform a vector search in the MongoDB collection based on the user query.
4
        """
5
        query_embedding = generate_embedding(user_query)
6
        if query_embedding is None:
7
            return "Invalid query or embedding generation failed."
8
9
        vector_search_stage = {
10
            "$vectorSearch": {
11
                "index": vector_search_index_name,
12
                "queryVector": query_embedding,
13
                "path": embedding_field_name,
14
                "numCandidates": top_k,
15
                "limit": 5,  # Return top 5 matches
16
            }
17
        }
18
19
        project_stage = {
20
            "$project": {
21
                "_id": 0,
22
                "fullplot": 1,
23
                "title": 1,
24
                "genres": 1,
25
                "score": {"$meta": "vectorSearchScore"},
26
            }
27
        }
28
29
        pipeline = [vector_search_stage, project_stage]
30
        results = collection.aggregate(pipeline)
31
        return list(results)

1
    import pprint
2
3
    query = "What are the some interesting action movies to watch that include business?"
4
    results = vector_search(query)
5
6
    print(f"\nTop 5 results for query '{query}':")
7
    for result in results:
8
        print(f"Title: {result['title']}, Score: {result['score']:.4f}")
9
10
    # Optionally, preview results as a DataFrame
11
    pd.DataFrame(results).head()

1
    from transformers import AutoTokenizer, AutoModelForCausalLM
2
3
    # Load DeepSeek model and tokenizer
4
    tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B", device_map="cuda")
5
    model = AutoModelForCausalLM.from_pretrained("deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B")
6
    model.to("cuda")
7
8
    def rag_query(user_query):
9
        # Retrieve matching documents using vector search
10
        retrieved_docs = vector_search(user_query)
11
        # Combine the query and search results into a context string
12
        combined_information = f"Query: {user_query}\nContinue to answer the query using the Search Results:\n{retrieved_docs}."
13
        
14
        # Tokenize input and move to GPU
15
        input_ids = tokenizer(combined_information, return_tensors="pt").to("cuda")
16
        response = model.generate(**input_ids, max_new_tokens=1000)
17
        return tokenizer.decode(response[0], skip_special_tokens=False)
18
19
    # Example query to generate a concise answer
20
    print(rag_query("What's a romantic movie that I can watch with my wife? Make your response concise"))