!pip install datasets langchain-couchbase langchain-cohere

[Output too long, omitted for brevity]

import json
import logging
import os
import time
import sys
import getpass
from datetime import timedelta
from uuid import uuid4

from couchbase.auth import PasswordAuthenticator
from couchbase.cluster import Cluster
from couchbase.exceptions import (CouchbaseException,
                                  InternalServerFailureException,
                                  QueryIndexAlreadyExistsException)
from couchbase.management.search import SearchIndex
from couchbase.options import ClusterOptions
from datasets import load_dataset
from langchain_cohere import ChatCohere, CohereEmbeddings
from langchain_core.documents import Document
from langchain_core.globals import set_llm_cache
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_couchbase.cache import CouchbaseCache
from langchain_couchbase.vectorstores import CouchbaseVectorStore
from tqdm import tqdm

/usr/local/lib/python3.10/dist-packages/pydantic/_internal/_config.py:341: UserWarning: Valid config keys have changed in V2:
* 'allow_population_by_field_name' has been renamed to 'populate_by_name'
* 'smart_union' has been removed
  warnings.warn(message, UserWarning)

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s',force=True)

COHERE_API_KEY = getpass.getpass('Enter your Cohere API key: ')
CB_HOST = input('Enter your Couchbase host (default: couchbase://localhost): ') or 'couchbase://localhost'
CB_USERNAME = input('Enter your Couchbase username (default: Administrator): ') or 'Administrator'
CB_PASSWORD = getpass.getpass('Enter your Couchbase password (default: password): ') or 'password'
CB_BUCKET_NAME = input('Enter your Couchbase bucket name (default: vector-search-testing): ') or 'vector-search-testing'
INDEX_NAME = input('Enter your index name (default: vector_search_cohere): ') or 'vector_search_cohere'
SCOPE_NAME = input('Enter your scope name (default: shared): ') or 'shared'
COLLECTION_NAME = input('Enter your collection name (default: cohere): ') or 'cohere'
CACHE_COLLECTION = input('Enter your cache collection name (default: cache): ') or 'cache'

# Check if the variables are correctly loaded
if not COHERE_API_KEY:
    raise ValueError("COHERE_API_KEY is not provided and is required.")

Enter your Cohere API key: ··········
Enter your Couchbase host (default: couchbase://localhost): couchbases://cb.hlcup4o4jmjr55yf.cloud.couchbase.com
Enter your Couchbase username (default: Administrator): vector-search-rag-demos
Enter your Couchbase password (default: password): ··········
Enter your Couchbase bucket name (default: vector-search-testing): 
Enter your index name (default: vector_search_cohere): 
Enter your scope name (default: shared): 
Enter your collection name (default: cohere): 
Enter your cache collection name (default: cache): 

try:
    auth = PasswordAuthenticator(CB_USERNAME, CB_PASSWORD)
    options = ClusterOptions(auth)
    cluster = Cluster(CB_HOST, options)
    cluster.wait_until_ready(timedelta(seconds=5))
    logging.info("Successfully connected to Couchbase")
except Exception as e:
    raise ConnectionError(f"Failed to connect to Couchbase: {str(e)}")

2024-08-29 12:37:48,036 - INFO - Successfully connected to Couchbase

def setup_collection(cluster, bucket_name, scope_name, collection_name):
    try:
        bucket = cluster.bucket(bucket_name)
        bucket_manager = bucket.collections()

        # Check if collection exists, create if it doesn't
        collections = bucket_manager.get_all_scopes()
        collection_exists = any(
            scope.name == scope_name and collection_name in [col.name for col in scope.collections]
            for scope in collections
        )

        if not collection_exists:
            logging.info(f"Collection '{collection_name}' does not exist. Creating it...")
            bucket_manager.create_collection(scope_name, collection_name)
            logging.info(f"Collection '{collection_name}' created successfully.")
        else:
            logging.info(f"Collection '{collection_name}' already exists.Skipping creation.")

        collection = bucket.scope(scope_name).collection(collection_name)

        # Ensure primary index exists
        try:
            cluster.query(f"CREATE PRIMARY INDEX IF NOT EXISTS ON `{bucket_name}`.`{scope_name}`.`{collection_name}`").execute()
            logging.info("Primary index present or created successfully.")
        except Exception as e:
            logging.warning(f"Error creating primary index: {str(e)}")

        # Clear all documents in the collection
        try:
            query = f"DELETE FROM `{bucket_name}`.`{scope_name}`.`{collection_name}`"
            cluster.query(query).execute()
            logging.info("All documents cleared from the collection.")
        except Exception as e:
            logging.warning(f"Error while clearing documents: {str(e)}. The collection might be empty.")

        return collection
    except Exception as e:
        raise RuntimeError(f"Error setting up collection: {str(e)}")

setup_collection(cluster, CB_BUCKET_NAME, SCOPE_NAME, COLLECTION_NAME)
setup_collection(cluster, CB_BUCKET_NAME, SCOPE_NAME, CACHE_COLLECTION)

2024-08-29 12:37:48,261 - INFO - Collection 'cohere' already exists.Skipping creation.
2024-08-29 12:37:48,300 - INFO - Primary index present or created successfully.
2024-08-29 12:37:48,981 - INFO - All documents cleared from the collection.
2024-08-29 12:37:49,020 - INFO - Collection 'cache' already exists.Skipping creation.
2024-08-29 12:37:49,056 - INFO - Primary index present or created successfully.
2024-08-29 12:37:49,104 - INFO - All documents cleared from the collection.





<couchbase.collection.Collection at 0x7e794bfcd570>

# If you are running this script locally (not in Google Colab), uncomment the following line
# and provide the path to your index definition file.

# index_definition_path = '/path_to_your_index_file/cohere_index.json'  # Local setup: specify your file path here

# If you are running in Google Colab, use the following code to upload the index definition file
from google.colab import files
print("Upload your index definition file")
uploaded = files.upload()
index_definition_path = list(uploaded.keys())[0]

try:
    with open(index_definition_path, 'r') as file:
        index_definition = json.load(file)
except Exception as e:
    raise ValueError(f"Error loading index definition from {index_definition_path}: {str(e)}")

Upload your index definition file


Saving cohere_index.json to cohere_index.json

try:
    scope_index_manager = cluster.bucket(CB_BUCKET_NAME).scope(SCOPE_NAME).search_indexes()

    # Check if index already exists
    existing_indexes = scope_index_manager.get_all_indexes()
    index_name = index_definition["name"]

    if index_name in [index.name for index in existing_indexes]:
        logging.info(f"Index '{index_name}' found")
    else:
        logging.info(f"Creating new index '{index_name}'...")

    # Create SearchIndex object from JSON definition
    search_index = SearchIndex.from_json(index_definition)

    # Upsert the index (create if not exists, update if exists)
    scope_index_manager.upsert_index(search_index)
    logging.info(f"Index '{index_name}' successfully created/updated.")

except QueryIndexAlreadyExistsException:
    logging.info(f"Index '{index_name}' already exists. Skipping creation/update.")

except InternalServerFailureException as e:
    error_message = str(e)
    logging.error(f"InternalServerFailureException raised: {error_message}")

    try:
        # Accessing the response_body attribute from the context
        error_context = e.context
        response_body = error_context.response_body
        if response_body:
            error_details = json.loads(response_body)
            error_message = error_details.get('error', '')

            if "collection: 'cohere' doesn't belong to scope: 'shared'" in error_message:
                raise ValueError("Collection 'cohere' does not belong to scope 'shared'. Please check the collection and scope names.")

    except ValueError as ve:
        logging.error(str(ve))
        raise

    except Exception as json_error:
        logging.error(f"Failed to parse the error message: {json_error}")
        raise RuntimeError(f"Internal server error while creating/updating search index: {error_message}")

2024-08-29 12:37:57,417 - INFO - Index 'vector_search_cohere' found
2024-08-29 12:37:57,576 - INFO - Index 'vector_search_cohere' already exists. Skipping creation/update.

try:
    trec = load_dataset('trec', split='train[:1000]')
    logging.info(f"Successfully loaded TREC dataset with {len(trec)} samples")
except Exception as e:
    raise ValueError(f"Error loading TREC dataset: {str(e)}")

/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_token.py:89: UserWarning: 
The secret `HF_TOKEN` does not exist in your Colab secrets.
To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.
You will be able to reuse this secret in all of your notebooks.
Please note that authentication is recommended but still optional to access public models or datasets.
  warnings.warn(



Downloading builder script:   0%|          | 0.00/5.09k [00:00<?, ?B/s]



Downloading readme:   0%|          | 0.00/10.6k [00:00<?, ?B/s]


The repository for trec contains custom code which must be executed to correctly load the dataset. You can inspect the repository content at https://hf.co/datasets/trec.
You can avoid this prompt in future by passing the argument `trust_remote_code=True`.

Do you wish to run the custom code? [y/N] y



Downloading data:   0%|          | 0.00/336k [00:00<?, ?B/s]



Downloading data:   0%|          | 0.00/23.4k [00:00<?, ?B/s]



Generating train split:   0%|          | 0/5452 [00:00<?, ? examples/s]



Generating test split:   0%|          | 0/500 [00:00<?, ? examples/s]


2024-08-29 12:38:05,036 - INFO - Successfully loaded TREC dataset with 1000 samples

try:
    embeddings = CohereEmbeddings(
        cohere_api_key=COHERE_API_KEY,
        model="embed-english-v3.0",
    )
    logging.info("Successfully created CohereEmbeddings")
except Exception as e:
    raise ValueError(f"Error creating CohereEmbeddings: {str(e)}")

2024-08-29 12:38:05,146 - INFO - Successfully created CohereEmbeddings

try:
    vector_store = CouchbaseVectorStore(
        cluster=cluster,
        bucket_name=CB_BUCKET_NAME,
        scope_name=SCOPE_NAME,
        collection_name=COLLECTION_NAME,
        embedding=embeddings,
        index_name=INDEX_NAME,
    )
    logging.info("Successfully created vector store")
except Exception as e:
    raise ValueError(f"Failed to create vector store: {str(e)}")

2024-08-29 12:38:05,749 - INFO - Successfully created vector store

try:
    batch_size = 50
    logging.disable(sys.maxsize) # Disable logging to prevent tqdm output
    for i in tqdm(range(0, len(trec['text']), batch_size), desc="Processing Batches"):
        batch = trec['text'][i:i + batch_size]
        documents = [Document(page_content=text) for text in batch]
        uuids = [str(uuid4()) for _ in range(len(documents))]
        vector_store.add_documents(documents=documents, ids=uuids)
    logging.disable(logging.NOTSET) # Re-enable logging
except Exception as e:
    raise RuntimeError(f"Failed to save documents to vector store: {str(e)}")

Processing Batches: 100%|██████████| 20/20 [00:22<00:00,  1.13s/it]

try:
    cache = CouchbaseCache(
        cluster=cluster,
        bucket_name=CB_BUCKET_NAME,
        scope_name=SCOPE_NAME,
        collection_name=CACHE_COLLECTION,
    )
    logging.info("Successfully created cache")
    set_llm_cache(cache)
except Exception as e:
    raise ValueError(f"Failed to create cache: {str(e)}")

2024-08-29 12:38:28,910 - INFO - Successfully created cache

try:
    llm = ChatCohere(
        cohere_api_key=COHERE_API_KEY,
        model="command",
        temperature=0
    )
    logging.info(f"Successfully created Cohere LLM with model command")
except Exception as e:
    raise ValueError(f"Error creating Cohere LLM: {str(e)}")

2024-08-29 12:38:29,015 - INFO - Successfully created Cohere LLM with model command

query = "Why do heavier objects travel downhill faster?"

try:
    # Perform the semantic search
    start_time = time.time()
    search_results = vector_store.similarity_search_with_score(query, k=10)
    search_elapsed_time = time.time() - start_time

    logging.info(f"Semantic search completed in {search_elapsed_time:.2f} seconds")

    # Display search results
    print(f"\nSemantic Search Results (completed in {search_elapsed_time:.2f} seconds):")
    for doc, score in search_results:
        print(f"Distance: {score:.4f}, Text: {doc.page_content}")

except CouchbaseException as e:
    raise RuntimeError(f"Error performing semantic search: {str(e)}")
except Exception as e:
    raise RuntimeError(f"Unexpected error: {str(e)}")

2024-08-29 12:38:29,072 - INFO - HTTP Request: POST https://api.cohere.com/v1/embed "HTTP/1.1 200 OK"
2024-08-29 12:38:29,273 - INFO - Semantic search completed in 0.25 seconds



Semantic Search Results (completed in 0.25 seconds):
Distance: 0.8184, Text: Why do heavier objects travel downhill faster ?
Distance: 0.3748, Text: What is a fear of passing high objects ?
Distance: 0.3322, Text: How fast is light ?
Distance: 0.3047, Text: How fast does the fastest car go ?
Distance: 0.2881, Text: What is the speed of the Mississippi River ?
Distance: 0.2881, Text: What is the speed of the Mississippi River ?
Distance: 0.2881, Text: What is the speed of the Mississippi River ?
Distance: 0.2872, Text: What makes a tornado turn ?
Distance: 0.2637, Text: What is the second hardest substance ?
Distance: 0.2623, Text: What makes thunder ?

try:
    template = """You are a helpful bot. If you cannot answer based on the context provided, respond with a generic answer. Answer the question as truthfully as possible using the context below:
    {context}

    Question: {question}"""
    prompt = ChatPromptTemplate.from_template(template)

    rag_chain = (
        {"context": vector_store.as_retriever(), "question": RunnablePassthrough()}
        | prompt
        | llm
        | StrOutputParser()
    )
    logging.info("Successfully created RAG chain")
except Exception as e:
    raise ValueError(f"Error creating RAG chain: {str(e)}")

2024-08-29 12:38:29,284 - INFO - Successfully created RAG chain

try:
    # Get RAG response
    logging.disable(sys.maxsize) # Disable logging
    start_time = time.time()
    rag_response = rag_chain.invoke(query)
    rag_elapsed_time = time.time() - start_time
    print(f"RAG Response: {rag_response}")
    print(f"RAG response generated in {rag_elapsed_time:.2f} seconds")
except Exception as e:
    raise ValueError(f"Error generating RAG response: {str(e)}")

RAG Response: Heavier objects travel downhill faster due to gravitational forces. As an object moves downhill, gravity accelerates the object, and velocity increases. The force of gravity is proportional to the object's mass, meaning heavier objects experience a more substantial gravitational force, leading to faster downhill speeds.

This relationship, known as the gravitational force equation, explains why heavier objects descend faster than lighter ones- 

```
force of gravity = gravitational force = acceleration due to gravity * mass = F = m*g
```

In this equation, the acceleration due to gravity is a constant value represented by `g`, and the mass `m` represents the object's mass. Consequently, the force of gravity is directly proportional to the object's mass, explaining heavier objects's downhill speed.

As a generic response, this explains the fundamental principle of gravity's impact on downhill speed, however, on a broader context, this answer refers to objects moving along a gravitational field, such as a hill.
RAG response generated in 6.45 seconds

try:
    queries = [
        "How does photosynthesis work?",
        "What is the capital of France?",
        "Why do heavier objects travel downhill faster?",  # Repeated query
        "How does photosynthesis work?",  # Repeated query
    ]

    for i, query in enumerate(queries, 1):
        print(f"\nQuery {i}: {query}")
        start_time = time.time()
        response = rag_chain.invoke(query)
        elapsed_time = time.time() - start_time
        print(f"Response: {response}")
        print(f"Time taken: {elapsed_time:.2f} seconds")
except Exception as e:
    raise ValueError(f"Error generating RAG response: {str(e)}")

Query 1: How does photosynthesis work?
Response: Photosynthesis is a process by which plants convert sunlight into chemical energy, specifically glucose. The process occurs in special structures called chloroplasts within the plant's cells. Here are the steps behind photosynthesis:

1. Absorption of sunlight: Chlorophyll, a pigment found in chloroplasts, captures the energy of sunlight.

2. Light reaction: The absorbed sunlight energizes electrons within the chloroplasts, initiating a series of complex reactions. During this stage, water molecules are split into hydrogen ions (H+), electrons (e^-), and oxygen atoms (O). The oxygen is released into the atmosphere as a byproduct, while the hydrogen ions and electrons are utilized in the next stage.

3. Carbon fixation: The energized hydrogen ions and electrons combine with carbon dioxide (CO2) in a process known as the Calvin cycle. Through a series of enzyme-mediated reactions, this combination produces glucose and other organic molecules that serve as the primary energy source and building blocks for the plant's growth and development. 

Overall, the essence of photosynthesis is the transformation of sunlight, water, and carbon dioxide into chemical energy (glucose) and oxygen. This process is essential for plant life and also serves as the primary energy source for almost all life on Earth, as plants are the primary producers in many ecosystems, forming the base of the food chain.
Time taken: 9.02 seconds

Query 2: What is the capital of France?
Response: Paris is the capital of France.
Time taken: 0.67 seconds

Query 3: Why do heavier objects travel downhill faster?
Response: Heavier objects travel downhill faster due to gravitational forces. As an object moves downhill, gravity accelerates the object, and velocity increases. The force of gravity is proportional to the object's mass, meaning heavier objects experience a more substantial gravitational force, leading to faster downhill speeds.

This relationship, known as the gravitational force equation, explains why heavier objects descend faster than lighter ones- 

```
force of gravity = gravitational force = acceleration due to gravity * mass = F = m*g
```

In this equation, the acceleration due to gravity is a constant value represented by `g`, and the mass `m` represents the object's mass. Consequently, the force of gravity is directly proportional to the object's mass, explaining heavier objects's downhill speed.

As a generic response, this explains the fundamental principle of gravity's impact on downhill speed, however, on a broader context, this answer refers to objects moving along a gravitational field, such as a hill.
Time taken: 0.46 seconds

Query 4: How does photosynthesis work?
Response: Photosynthesis is a process by which plants convert sunlight into chemical energy, specifically glucose. The process occurs in special structures called chloroplasts within the plant's cells. Here are the steps behind photosynthesis:

1. Absorption of sunlight: Chlorophyll, a pigment found in chloroplasts, captures the energy of sunlight.

2. Light reaction: The absorbed sunlight energizes electrons within the chloroplasts, initiating a series of complex reactions. During this stage, water molecules are split into hydrogen ions (H+), electrons (e^-), and oxygen atoms (O). The oxygen is released into the atmosphere as a byproduct, while the hydrogen ions and electrons are utilized in the next stage.

3. Carbon fixation: The energized hydrogen ions and electrons combine with carbon dioxide (CO2) in a process known as the Calvin cycle. Through a series of enzyme-mediated reactions, this combination produces glucose and other organic molecules that serve as the primary energy source and building blocks for the plant's growth and development. 

Overall, the essence of photosynthesis is the transformation of sunlight, water, and carbon dioxide into chemical energy (glucose) and oxygen. This process is essential for plant life and also serves as the primary energy source for almost all life on Earth, as plants are the primary producers in many ecosystems, forming the base of the food chain.
Time taken: 0.26 seconds