Support to add embedding and vector database

[veeramanikandanvv]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

To the below code please add embedding functionality for documents and store to a vector database.

from typing import Any, Dict, List, Optional
import hmac
import hashlib
import base64
import json
import requests
import time
import uuid
from langchain_core.callbacks.manager import CallbackManagerForLLMRun
from langchain_core.language_models.llms import LLM

class HMACAuthenticatedLLM(LLM):
    """A custom LLM that uses HMAC authentication to connect to a model."""

    api_key: str
    secret_key: str
    endpoint: str

    def _call(
        self,
        prompt: str,
        stop: Optional[List[str]] = None,
        run_manager: Optional[CallbackManagerForLLMRun] = None,
        **kwargs: Any,
    ) -> str:
        """Run the LLM on the given input with HMAC authentication.

        Args:
            prompt: The prompt to generate from.
            stop: Stop words to use when generating.
            run_manager: Callback manager for the run.
            **kwargs: Arbitrary additional keyword arguments.

        Returns:
            The model output as a string.
        """
        if stop is not None:
            raise ValueError("stop kwargs are not permitted.")

        # Create request body
        request_body = {
            "messages": [
                {"content": "", "role": "system"},
                {"content": prompt, "role": "user"},
            ],
            "frequency_penalty": 0,
            "max_tokens": 1000,
            "n": 1,
            "presence_penalty": 0,
            "response_format": {"type": "text"},
            "stream": False,
            "temperature": 0.6,
            "top_p": 1
        }

        # Create HMAC signature
        timestamp = int(time.time() * 1000)
        request_id = uuid.uuid4()
        hmac_source_data = self.api_key + str(request_id) + str(timestamp) + json.dumps(request_body)
        computed_hash = hmac.new(self.secret_key.encode(), hmac_source_data.encode(), hashlib.sha256)
        hmac_signature = base64.b64encode(computed_hash.digest()).decode()

        # Send request to the model
        headers = {
            "api-key": self.api_key,
            "Client-Request-Id": str(request_id),
            "Timestamp": str(timestamp),
            "Authorization": hmac_signature,
            "Accept": "application/json",
        }
        response = requests.post(self.endpoint + "/chat/completions", headers=headers, json=request_body)
        response.raise_for_status()

        return response.json().get('choices', [{}])[0].get('message', {}).get('content', '')

    @property
    def _llm_type(self) -> str:
        """Get the type of language model used by this chat model. Used for logging purposes only."""
        return "hmac_authenticated"

# Example usage
llm = HMACAuthenticatedLLM(api_key='your_api_key', secret_key='your_secret_key', endpoint='https://api.yourmodel.com')
print(llm.invoke("This is a test prompt"))

Description

To the below code please add embedding functionality for documents and store to a vector database.

from typing import Any, Dict, List, Optional
import hmac
import hashlib
import base64
import json
import requests
import time
import uuid
from langchain_core.callbacks.manager import CallbackManagerForLLMRun
from langchain_core.language_models.llms import LLM

class HMACAuthenticatedLLM(LLM):
"""A custom LLM that uses HMAC authentication to connect to a model."""

api_key: str
secret_key: str
endpoint: str

def _call(
    self,
    prompt: str,
    stop: Optional[List[str]] = None,
    run_manager: Optional[CallbackManagerForLLMRun] = None,
    **kwargs: Any,
) -> str:
    """Run the LLM on the given input with HMAC authentication.

    Args:
        prompt: The prompt to generate from.
        stop: Stop words to use when generating.
        run_manager: Callback manager for the run.
        **kwargs: Arbitrary additional keyword arguments.

    Returns:
        The model output as a string.
    """
    if stop is not None:
        raise ValueError("stop kwargs are not permitted.")

    # Create request body
    request_body = {
        "messages": [
            {"content": "", "role": "system"},
            {"content": prompt, "role": "user"},
        ],
        "frequency_penalty": 0,
        "max_tokens": 1000,
        "n": 1,
        "presence_penalty": 0,
        "response_format": {"type": "text"},
        "stream": False,
        "temperature": 0.6,
        "top_p": 1
    }

    # Create HMAC signature
    timestamp = int(time.time() * 1000)
    request_id = uuid.uuid4()
    hmac_source_data = self.api_key + str(request_id) + str(timestamp) + json.dumps(request_body)
    computed_hash = hmac.new(self.secret_key.encode(), hmac_source_data.encode(), hashlib.sha256)
    hmac_signature = base64.b64encode(computed_hash.digest()).decode()

    # Send request to the model
    headers = {
        "api-key": self.api_key,
        "Client-Request-Id": str(request_id),
        "Timestamp": str(timestamp),
        "Authorization": hmac_signature,
        "Accept": "application/json",
    }
    response = requests.post(self.endpoint + "/chat/completions", headers=headers, json=request_body)
    response.raise_for_status()

    return response.json().get('choices', [{}])[0].get('message', {}).get('content', '')

@property
def _llm_type(self) -> str:
    """Get the type of language model used by this chat model. Used for logging purposes only."""
    return "hmac_authenticated"

Example usage

llm = HMACAuthenticatedLLM(api_key='your_api_key', secret_key='your_secret_key', endpoint='https://api.yourmodel.com')
print(llm.invoke("This is a test prompt"))

System Info

To the below code please add embedding functionality for documents and store to a vector database.

from typing import Any, Dict, List, Optional
import hmac
import hashlib
import base64
import json
import requests
import time
import uuid
from langchain_core.callbacks.manager import CallbackManagerForLLMRun
from langchain_core.language_models.llms import LLM

class HMACAuthenticatedLLM(LLM):
"""A custom LLM that uses HMAC authentication to connect to a model."""

api_key: str
secret_key: str
endpoint: str

def _call(
    self,
    prompt: str,
    stop: Optional[List[str]] = None,
    run_manager: Optional[CallbackManagerForLLMRun] = None,
    **kwargs: Any,
) -> str:
    """Run the LLM on the given input with HMAC authentication.

    Args:
        prompt: The prompt to generate from.
        stop: Stop words to use when generating.
        run_manager: Callback manager for the run.
        **kwargs: Arbitrary additional keyword arguments.

    Returns:
        The model output as a string.
    """
    if stop is not None:
        raise ValueError("stop kwargs are not permitted.")

    # Create request body
    request_body = {
        "messages": [
            {"content": "", "role": "system"},
            {"content": prompt, "role": "user"},
        ],
        "frequency_penalty": 0,
        "max_tokens": 1000,
        "n": 1,
        "presence_penalty": 0,
        "response_format": {"type": "text"},
        "stream": False,
        "temperature": 0.6,
        "top_p": 1
    }

    # Create HMAC signature
    timestamp = int(time.time() * 1000)
    request_id = uuid.uuid4()
    hmac_source_data = self.api_key + str(request_id) + str(timestamp) + json.dumps(request_body)
    computed_hash = hmac.new(self.secret_key.encode(), hmac_source_data.encode(), hashlib.sha256)
    hmac_signature = base64.b64encode(computed_hash.digest()).decode()

    # Send request to the model
    headers = {
        "api-key": self.api_key,
        "Client-Request-Id": str(request_id),
        "Timestamp": str(timestamp),
        "Authorization": hmac_signature,
        "Accept": "application/json",
    }
    response = requests.post(self.endpoint + "/chat/completions", headers=headers, json=request_body)
    response.raise_for_status()

    return response.json().get('choices', [{}])[0].get('message', {}).get('content', '')

@property
def _llm_type(self) -> str:
    """Get the type of language model used by this chat model. Used for logging purposes only."""
    return "hmac_authenticated"

Example usage

llm = HMACAuthenticatedLLM(api_key='your_api_key', secret_key='your_secret_key', endpoint='https://api.yourmodel.com')
print(llm.invoke("This is a test prompt"))