LangChain Integration

from pygridgain import Client
from pygridgain.exceptions import AuthenticationError

def connect_to_gridgain(username: str, password: str, url: str, port: int) -> Client:
    try:
        # Create client configuration
        client = Client(username=username, password=password, use_ssl=True)

        # Connect to the cluster
        client.connect(url, port)
        print("Connected to GridGain successfully.")
        return client
    except AuthenticationError:
        print("Authentication failed. Please check your username and password.")
        raise
    except Exception as e:
        print(f"Failed to connect to GridGain: {e}")
        raise

# Example usage
try:
    client = connect_to_gridgain(
        username="your_username",
        password="your_password",
        url="gridgain.example.com",
        port=10800
    )
except Exception as e:
    print(f"Connection failed: {e}")

from langchain_community.storage.ignite import GridGainStore

def initialize_keyvalue_store(client) -> GridGainStore:
    try:
        key_value_store = GridGainStore(
            cache_name="laptop_specs",
            client=client
        )
        print("GridGainStore initialized successfully.")
        return key_value_store
    except Exception as e:
        print(f"Failed to initialize GridGainStore: {e}")
        raise

# Usage
client = connect_to_ignite("localhost", 10800)
key_value_store = initialize_keyvalue_store(client)

# Store a value
key_value_store.mset([("laptop1", "16GB RAM, NVIDIA RTX 3060, Intel i7 11th Gen")])

# Retrieve a value
specs = key_value_store.mget(["laptop1"])[0]

from langchain_community.document_loaders.ignite import GridGainDocumentLoader

def initialize_doc_loader(client) -> GridGainDocumentLoader:
    try:
        doc_loader = GridGainDocumentLoader(
            cache_name="review_cache",
            client=client,
            create_cache_if_not_exists=True
        )
        print("GridGainDocumentLoader initialized successfully.")
        return doc_loader
    except Exception as e:
        print(f"Failed to initialize GridGainDocumentLoader: {e}")
        raise

# Usage
client = connect_to_ignite("localhost", 10800)
doc_loader = initialize_doc_loader(client)

# Populate the cache
reviews = {
    "laptop1": "Great performance for coding and video editing. The 16GB RAM and dedicated GPU make multitasking a breeze."
}
doc_loader.populate_cache(reviews)

# Load documents
documents = doc_loader.load()

from langchain_community.chat_message_histories.ignite import GridGainChatMessageHistory

def initialize_chathistory_store(client) -> GridGainChatMessageHistory:
    try:
        chat_history = GridGainChatMessageHistory(
            session_id="user_session",
            cache_name="chat_history",
            client=client
        )
        print("GridGainChatMessageHistory initialized successfully.")
        return chat_history
    except Exception as e:
        print(f"Failed to initialize GridGainChatMessageHistory: {e}")
        raise

# Usage
client = connect_to_ignite("localhost", 10800)
chat_history = initialize_chathistory_store(client)

# Add a message to the history
chat_history.add_user_message("Hello, I need help choosing a laptop.")

# Retrieve the conversation history
messages = chat_history.messages

from langchain_community.llm_cache.ignite import GridGainCache
from utils import connect_to_ignite, initialize_llm_cache

# Connect to GridGain/Ignite
client = connect_to_ignite("localhost", 10800)

# Initialize GridGainCache
llm_cache = initialize_llm_cache(client)

# Set up your LLM (e.g., OpenAI)
from langchain_openai import OpenAI
llm = OpenAI()

# Set the cache for the LLM
llm.cache = llm_cache

# Use the LLM in your application
response = llm.predict("What are the key features to consider when buying a laptop for video editing?")
print(response)

from langchain_community.llm_cache.ignite import GridGainSemanticCache
from langchain_openai import OpenAIEmbeddings
from utils import connect_to_ignite, initialize_semantic_llm_cache, initialize_embeddings_model

# Connect to GridGain/Ignite
client = connect_to_ignite("localhost", 10800)

# Initialize embedding model
api_key = os.environ["OPENAI_API_KEY"]
embedding_model = initialize_embeddings_model(api_key)

# Initialize GridGainSemanticCache
api_endpoint = "http://localhost:8080"
semantic_cache = initialize_semantic_llm_cache(client, embedding_model, api_endpoint)

# Set up your LLM (e.g., OpenAI)
from langchain_openai import OpenAI
llm = OpenAI()

# Set the cache for the LLM
llm.cache = semantic_cache

# Use the LLM in your application
response = llm.predict("What are the key features to consider when buying a laptop for video editing?")
print(response)

from langchain_community.vectorstores import GridGainVectorStore
from utils import initialize_embeddings_model, initialize_vector_store

# Initialize embedding model
api_key = os.environ["OPENAI_API_KEY"]
embedding_model = initialize_embeddings_model(api_key)

# Initialize GridGainVectorStore
api_endpoint = "http://localhost:8080"
vector_store = initialize_vector_store(api_endpoint, embedding_model)

# Add texts to the vector store
texts = [
    "The latest MacBook Pro offers exceptional performance for video editing.",
    "Dell XPS 15 is a powerful Windows laptop suitable for creative professionals.",
    "ASUS ROG Zephyrus G14 provides a balance of portability and gaming performance."
]
metadatas = [{"id": "tech_review_1"}, {"id": "tech_review_2"}, {"id": "tech_review_3"}]

vector_store.add_texts(texts=texts, metadatas=metadatas)

# Perform similarity search
query = "What's a good laptop for video editing?"
results = vector_store.similarity_search(query, k=2)

for doc in results:
    print(f"Content: {doc.page_content}")
    print(f"Metadata: {doc.metadata}")
    print("---")

# Clear the vector store
vector_store.clear()