ChatGPT on top of Langchain Repo and Docs

[CollectivAI]

ChatGPT+ didn't have any context of Langchain, so we at Collectiv made a LLM-Chain and gave it the
Langchain docs & the repo. Would be open-sourcing this and host it for folks building on Langchain. For now, you can access it here. More details in the tweet.

Hope it helps!

[slavakurilyak]

@CollectivAI Congrats on the launch Akash! Any plans to open-source the web app so other LangChain developers can better leverage your work?

[sergerdn]

@CollectivAI

"ChatGPT on your entire Code & Knowledge Base"
I am currently working on integrating ChatGPT with my entire code and knowledge base. It doesn't seem too difficult, but once you know what needs to be done, it should be manageable.

[nischalj10]

@slavakurilyak Thanks! We do plan to open-source it, however currently packed up with a lot of stuff. We will definitely do improvements on LangChainX in either case.

[nischalj10]

@sergerdn for someone good at the stuff, sure, not immensely hard. However, we are making a custom data ingestion pipeline that structures data in a way that results are better than directly feeding the semantic search to the LLM for context. We also plan more integrations in the near future. Excited to hear your plans too on this!

[sergerdn]

@sergerdn for someone good at the stuff, sure, not immensely hard. However, we are making a custom data ingestion pipeline that structures data in a way that results are better than directly feeding the semantic search to the LLM for context. We also plan more integrations in the near future. Excited to hear your plans too on this!

My first step was to develop scripts that work directly with the Open API. This will enable me to gain a better understanding of the various components involved and how they can be implemented using Langchain.

Here is one of my old drafts of my chat. It looks very unpolished, but it has helped me to understand many things.

import asyncio
import logging
import os
import re
from typing import List

import chromadb
import openai
from dotenv import load_dotenv
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma

load_dotenv(dotenv_path="../.env", verbose=True)
logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s %(levelname)s %(message)s",
    filemode="w", filename=os.path.join(os.path.dirname(__file__), "log_chat.txt"),
)

ABS_PATH = os.path.dirname(os.path.abspath(__file__))
DB_DIR = os.path.join(ABS_PATH, "db")


def color_text(text, color_code):
    return f"\033[{color_code}m{text}\033[0m"


def handle_rate_limit(retry_interval: float = 0.1):
    def decorator(func):
        async def inner(*args, **kwargs):
            while True:
                try:
                    return await func(*args, **kwargs)
                except openai.error.RateLimitError as e:
                    print(f"Rate limit exceeded. Retrying in {retry_interval} seconds...")
                    await asyncio.sleep(retry_interval)
                except openai.error.InvalidRequestError as e:
                    print(args, kwargs)
                    print(f"Invalid request: {e}")
                    raise e

        return inner

    return decorator


@handle_rate_limit(retry_interval=0.1)
async def get_answer_from_messages(messages: List) -> openai.api_resources.completion.Completion:
    try:
        response = await openai.ChatCompletion.acreate(
            model="gpt-3.5-turbo",
            messages=messages,
        )
    except openai.error.InvalidRequestError as e:
        if "This model's maximum context length is " not in str(e):
            raise e
        print("Context is too long. Trying to split it: ", str(e))
        del messages[1]
        return await get_answer_from_messages(messages)

    return response


@handle_rate_limit(retry_interval=0.1)
async def prepare_query(query: str) -> str:
    response = await openai.Completion.acreate(
        engine="text-davinci-003",
        prompt=f"Detect language and correct this to standard, print only corrected:\n\n{query}",
        n=1,
        stop=None,
        temperature=0.1,
    )

    normalized_query = response.choices[0].text.strip()
    return normalized_query


async def query_chromadb(query: str = "who is FREDERICK?"):
    openai_api_key = os.getenv("OPENAI_API_KEY")
    if not openai_api_key:
        raise ValueError("OPENAI_API_KEY environment variable is not set")

    client_settings = chromadb.config.Settings(
        chroma_db_impl="duckdb+parquet",
        persist_directory=DB_DIR,
        anonymized_telemetry=False
    )

    embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)

    vectorstore = Chroma(
        collection_name="langchain_store",
        embedding_function=embeddings,
        client_settings=client_settings,
        persist_directory=DB_DIR,
    )
    messages = [
        {
            "role": "system",
            "content": """You are an AI assistant providing helpful advice. Please think carefully and provide 
                answers step by step. You are given the following extracted parts of a long document and a question. 
                Provide a conversational answer based on the context provided. Get all variants of your possible answers 
                ranged by score."""
        }

    ]
    messages[0]["content"] = messages[0]["content"].replace("\n", " ")
    messages[0]["content"] = re.sub(r'\s+', ' ', messages[0]["content"])

    while True:
        logging.debug(messages)
        query = input(color_text("Enter your question (type 'exit' to quit): ", 34))
        if query.lower() == 'exit':
            break
        query = query.strip()
        query_norm = await prepare_query(query)

        logging.debug(f"\n query: {query}, \n normalized query: {query_norm}")
        print(color_text("normalized query:", 31), query_norm)

        # Perform similarity search
        result = vectorstore.similarity_search_with_score(query=query_norm, k=1)

        # Prepare context for OpenAI API
        max_len = 4097
        context_template = "Source: {source}\n{page_content}\n\n"
        context = ""
        for num, item in enumerate(result):
            doc, score = item
            source = doc.metadata['source']

            available_length = max_len - len(context) - len(context_template.format(source=source, page_content=""))

            if available_length <= 0:
                break

            truncated_page_content = doc.page_content[:available_length]
            context += context_template.format(source=source, page_content=truncated_page_content)

        # Call OpenAI API with the question and relevant documents as context
        prompt = f"Question: {query_norm}\n\nContext:\n{context}\nAnswer:"

        messages.append({"role": "user", "content": prompt})
        response = await get_answer_from_messages(messages)
        answer = response.choices[0]["message"]["content"].strip()
        print(color_text("AI:", 32), answer)

        messages.append({"role": "assistant", "content": answer})


async def run():
    await query_chromadb()


if __name__ == '__main__':
    asyncio.run(run())

[sergerdn]

@CollectivAI

It seems like ChatGPT knows something about you.😅

[CollectivAI]

Its about time world knows about us! Lol :D