Advent of GenAI Hackathon: Recap of Challenge 4

QUESTION: What is the armor class of a Black Dragon?
RETRIEVED(first part of database record): {'name': 'Ancient Black Dragon
ANSWER: The Black Dragon, a colossal beast with scales as dark as the abyss, boasts an armor class of 17. But do not be deceived by this seemingly low number, for its natural armor is a formidable defense against even the mightiest of foes. Beware its wrath, for the Black Dragon is a force to be reckoned with! 

QUESTION: Is a Purple Worm wise?
RETRIEVED(first part of database record): {'name': 'Purple Worm', 'meta'
ANSWER: Purple Worm, a colossal beast that dwells in the depths of the earth. Its wisdom is unmatched, for it has seen the very foundations of the world shift and change. Its Intelligence score of 18 and Wisdom score of 19 are a testament to its unparalleled intellect and insight. Beware its wrath, for the Purple Worm is a force to be reckoned with! 

QUESTION: Tell me about a Quasit's agility.
RETRIEVED(first part of database record): {'name': 'Quasit', 'meta': 'Ti
ANSWER: Quasit, a vile creature of the abyss, is not just a master of deception and manipulation, but also a formidable foe in combat. Its agility is unmatched, with a Dexterity score of 17 and a Dexterity modifier of +3. It moves with a speed that defies the laws of mortal beings, darting in and out of shadows with ease. Its nimbleness allows it to dodge and weave through attacks, making it a challenging target to hit. Beware its quick reflexes and cunning tactics, for the Quasit is a force to be reckoned with! 

QUESTION: Is a Giant Wasp perceptive?
RETRIEVED(first part of database record): {'name': 'Giant Wasp', 'meta':
ANSWER: Giant Wasp, a vile creature of the wilderness. Its senses are razor-sharp, honed by years of hunting prey in the dead of night. Its Wisdom score of 15 and Perception score of 16 are a testament to its unparalleled insight and perception. Beware its keen senses, for the Giant Wasp is a force to be reckoned with!

QUESTION: Is a Rakshasa it strong?
RETRIEVED(first part of database record): {'name': 'Rakshasa', 'meta': '
ANSWER: Rakshasa, a cunning and malevolent creature that lurks in the shadows. Its strength is not to be underestimated, for its Might score of 17 and Strength modifier of +3 are a testament to its formidable physique. But it is not just its brawn that makes it a force to be reckoned with, for its intellect and guile are equally impressive. Beware its cunning tactics and deceitful nature, for the Rakshasa is a force to be reckoned with! 

QUESTION: Tell me about a Raven's traits.
RETRIEVED(first part of database record): {'name': 'Raven', 'meta': 'Tin
ANSWER: Raven, a cunning and malevolent creature that lurks in the shadows. Its intelligence is unmatched, with a Wisdom score of 18 and an Intelligence score of 17, a testament to its unparalleled intellect and guile. But it is not just its mind that makes it a force to be reckoned with, for its physical prowess is equally impressive. Its Strength score of 15 and its Strength modifier of +2 are a testament to its formidable physique. Beware its cunning tactics and deceitful nature, for the Raven is a force to be reckoned with!

The code is set out below. Please note that the monsters.json file was necessary for its execution:

import os
import json

from langchain import LLMChain
from langchain.llms import PredictionGuard

import predictionguard as pg
from langchain.prompts import PromptTemplate
from langchain.document_loaders import JSONLoader

import lancedb
from lancedb.embeddings import with_embeddings
from sentence_transformers import SentenceTransformer

from datasets import load_dataset
import pandas as pd


class Chatbot():
    def __init__(self):
        
        os.environ["PREDICTIONGUARD_TOKEN"] = "xQZQCxe46UmYwYhjE6C0anJXec8bccK2mOXzwyvj"

        # Zephyr 'syntax'

        # Everything you see tagged with <|system|> is what the LLM expects as the main instruction, defining how it should approach user input. Everything tagged with <|user|> is what the LLM expects as user input, or even more broadly put, what it expects at "query time". Finally, <|assistant|> tags the part of the prompt that the model will complete.
        self.info_context = ''

        # Initialize an empty list to store the last three entries in the info_context
        self.info_context_history = ""

        _monster_prompt_template = ("<|system|>You are a helpful assistant who is extremely knowledgeable about Dungeons and Dragons 5th Edition monsters. Your job is to help explain the important and interesting features of these monsters. Give a comprehensive answer to the question. Do so in the manner of an overacted, but honest villain.</s>\n"
            "<|user|>\n"
            "Context: {conversational_context}{info_context}\n"
            "Question: {query}\n"
            "</s>\n"
            "<|assistant|>\n"
        )
        
        self.conversational_context = [
            "user - What is the armor class of an Aboleth?\n"
            "assistant - The slippery Aboleth! Its feeble armor class is a mere 17, a laughable attempt at self-preservation through natural armor.",
            "user - Is the Aboleth evil?\n"
            "assistant - Evil, you ask? Chaotic evil courses through the veins of the wretched Aboleth! A malevolent force, craving nothing but chaos and destruction.",
            "user - What kind of creature is a black dragon?\n"
            "assistant - The black dragon! A colossal beast with scales as dark as the abyss. It commands fear, intelligence, and a loyalty that rivals even the most treacherous creatures. Beware its breath, a torrent of acid, a venomous cascade capable of melting steel!",
            "user - Is it strong?\n"
            "assistant - Strong? The Large Black Dragon is a behemoth! A strength of 23 and a strength modifier of +6. It scoffs at feeble attempts to challenge its might!"
        ]

        monster_prompt = PromptTemplate(template=_monster_prompt_template, input_variables=["info_context", "conversational_context", "query"])


        self.monster_model = LLMChain(prompt=monster_prompt, llm=PredictionGuard(model="Zephyr-7B-Beta"), verbose=False)

    def _update_info_context_history(self, new_info_entry):
        # Set the info_context to the new entry
        self.info_context_history = new_info_entry

    def _update_conversational_context(self, query, answer):
        # Update the conversational context with the new user query and assistant answer
        self.conversational_context.append(f"user - {query}\nassistant - {answer}\n")

        # print("Convo Context:",self.conversational_context)
        # print("Info Context History:", self.info_context_history)

        return self.conversational_context[:-3]
    

    def query_model(self, query):

        print("\n\n\nQUESTION:", query)
        new_info_context = self.rag_context_from_monster_table(query)
        print("RETRIEVED(first part of database record):",new_info_context[:30])
        self._update_info_context_history(new_info_context)
        answer = self.query_monster_model(query)
        if "\n\n" in answer:
            answer = answer.split("\n\n")[0]
        
        print("ANSWER:", answer )
        return answer

    def query_monster_model(self, query):
        answer = self.monster_model.predict(conversational_context = self.conversational_context, info_context = self.info_context, query = query, temperature=0.8, max_tokens=100 )
        self._update_conversational_context(query, answer)
        return answer
    
    def rag_context_from_monster_table(self, message):
        def embed(sentence):
            return embedding_model.encode(sentence)

        results = monster_table.search(embed(message)).limit(5).to_pandas()
        results.sort_values(by=["_distance"], inplace=True, ascending=True)
        return results["text"].values[0]


def init_monster_table(embedding_model):
    file_path = "monsters.json"

    # Open and read the contents of the JSON file)
    with open(file_path, "r") as file:
        monsters_data = json.load(file)

    for data in monsters_data:
        data.pop("img_url")

    # Embedding data

    def embed_batch(batch):
        return [embedding_model.encode(sentence) for sentence in batch]

    metadata = []
    for i in range(len(monsters_data)):
        metadata.append([i, str(monsters_data[i])])
    doc_df = pd.DataFrame(metadata, columns=["chunk", "text"])
    embedded_data = with_embeddings(embed_batch, doc_df)


    # Creating lance database
    uri = "lancedb_challenge4"
    db = lancedb.connect(uri)
    try:
        db.create_table("dnd_monsters", data=embedded_data)
        table = db.open_table("dnd_monsters")
        table.add(data=embedded_data)
    except:
        table = db.open_table("dnd_monsters")

    return table

def demo(chat):

    chat.info_context = chat.rag_context_from_monster_table("aboleth")

    query = "What is the armor class of a Black Dragon?"
    chat.query_model(query)

    query = "Is a Purple Worm wise?"
    chat.query_model(query)

    query = "Tell me about a Quasit's agility."
    chat.query_model(query)

    query = "Is a Giant Wasp perceptive?"
    chat.query_model(query)

    query = "Is a Rakshasa it strong?"
    chat.query_model(query)

    query = "Tell me about a Raven's traits."
    chat.query_model(query)


if __name__ == "__main__":
    embedding_model = SentenceTransformer("all-MiniLM-L12-v2")
    monster_table = init_monster_table(embedding_model)

    chat = Chatbot()

    chat.info_context = chat.rag_context_from_monster_table("aboleth")

    demo(chat)

Honorable Mentions

We are excited to honor the additional outstanding projects by Vikas Reddy, Vincent Müller, Alvin Lee, Vedant Tamgadge, Strikanth Thokala, Allen McCrea, Samy Gauquelin, Asaad Almutareb, Simon Schafer, and Faraz Ahmad. 

Join the Intel® Liftoff Program

Are you inspired by these remarkable innovations? If you're an AI developer or startup founder looking to elevate your project, consider joining the Intel® Liftoff Program for Startups. This program provides resources, community support, and a platform to take your tech innovations to the next level.