Add knowledge domain router

README.MD

@@ -13,6 +13,12 @@ Strategies for jupyter, gradio, and react will be prioritized in general at this
 General problem solving requiring reasoned processing. Utilizing tree of thoughts, chain of thought, and reAct. Current prompts heavily inspired by
 work from https://github.com/mrspiggot
 
+### Knowledge Domains
+
+Example of knowledge domain retrieval. Given a question the router determines the best knowledge domain chain to use and then calls that chain to handle the response.
+
+Includes examples of queries that will return each of the four implemented domains. 
+
 ### Generative Image Prompting Patterns
 
 Coming soon 

modules/base/chain.py

@@ -0,0 +1,21 @@
+from loguru import logger
+from pydantic import BaseModel
+
+class IChain(BaseModel):
+    """
+    IChain Class (Interface for Chain)
+
+    Design:
+    This class is an interface that defines the basic structure for a chain class. It's not intended to be 
+    instantiated directly, but should be extended by other classes that implement the run method. This follows 
+    the Interface Segregation Principle (ISP), as it provides a simple, specific interface for chain classes.
+
+    Intended Implementation:
+    Classes that extend IChain should provide an implementation for the run method. The run method should take 
+    a string input and return a string output. The specifics of what the run method does will depend on the 
+    requirements of the subclass.
+    """
+    def run(self, input: str) -> str:
+        logger.info("Running IChain with input: {}", input)
+        pass
+

modules/base/llm_chain_config.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel
+from langchain.llms.base import BaseLLM
+from langchain.llms import OpenAI
+from typing import Type
+
+class LLMChainConfig(BaseModel):
+    """
+    A configuration class for the chain strategy.
+
+    Attributes:
+        temperature (float): The temperature parameter for the language model.
+        max_tokens (int): The maximum number of tokens to generate.
+        llm_class (Type[BaseLLM]): The language model class to use for reasoning.
+        usage (str): String describing when it is appropriate to use this chain strategy. 
+    """
+    temperature: float = 0.7
+    max_tokens: int = 1500
+    llm_class: Type[BaseLLM] = OpenAI # Overrideable default
+    usage: str

modules/knowledge_retrieval/base/__init__.py

@@ -0,0 +1,2 @@
+from modules.knowledge_retrieval.base.router_chain import RouterChain
+from modules.knowledge_retrieval.base.knowledge_domain import KnowledgeDomain

modules/knowledge_retrieval/base/knowledge_domain.py

@@ -0,0 +1,21 @@
+from pydantic import BaseModel
+from loguru import logger
+
+class KnowledgeDomain(BaseModel):
+    """
+    KnowledgeDomain Class
+
+    Design:
+    This class acts as a base for knowledge domain classes. It's not intended to be instantiated directly, 
+    but should be extended by other classes that provide a specific implementation for the generate_response method. 
+    This adheres to the Open/Closed Principle (OCP) and Liskov Substitution Principle (LSP) by providing a base 
+    class that can be extended without modification.
+
+    Intended Implementation:
+    Classes that extend KnowledgeDomain should provide an implementation for the generate_response method. 
+    The generate_response method should take a question string as input and return a response string. The 
+    specifics of how the response is generated will depend on the requirements of the subclass.
+    """
+    def generate_response(self, question: str) -> str:
+        logger.info("Generating response for question: {}", question)
+        pass

modules/knowledge_retrieval/base/router_chain.py

@@ -0,0 +1,32 @@
+from modules.base.chain import IChain
+from typing import Dict , Any, Callable
+import os
+
+class RouterChain(IChain):
+    """
+    RouterChain Class
+
+    Design:
+    The RouterChain class extends the IChain interface and provides an implementation for the run 
+    method. It also introduces a new method, add_chain, for adding destination chains. The class adheres 
+    to the Open/Closed Principle (OCP) as it can be extended without modifying its behavior.
+
+    Intended Implementation:
+    The RouterChain class serves as a router that selects the appropriate DestinationChain based on 
+    the input. The selection logic should be implemented in the run method. The add_chain method 
+    allows new DestinationChain instances to be added to the RouterChain.
+    """
+    template : str 
+    destination_chains: Dict[int, IChain]
+    display: Callable = print
+    question: str
+    usage: str
+    llm: Any
+    api_key: str = os.environ.get('OPENAI_API_KEY')
+
+    def add_chain(self, domain: str, chain: IChain) -> None:
+        self.destination_chains[domain] = chain
+
+    def run(self, input: str) -> str:
+        # Implement the logic to select the appropriate DestinationChain
+        pass

modules/knowledge_retrieval/component.py

@@ -0,0 +1,26 @@
+from modules.knowledge_retrieval.knowledge_router import KnowledgeDomainRouter, get_knowledge_domain_router_config
+import gradio as gr
+import os 
+openai_api_key = os.getenv("OPENAI_API_KEY")
+
+def determine_and_execute(question: str, temperature: float):
+    config = get_knowledge_domain_router_config(temperature=temperature)
+    config.temperature = temperature
+    determiner = KnowledgeDomainRouter(api_key=openai_api_key, config=config, question=question, display=print)
+    determine_output, execute_output = determiner.determine_and_execute(question=question)
+    return determine_output, execute_output
+
+examples = [["""When is my grandmothers birthday?""", 0.6], ["What was my tax burden last year?", 0.6 ], ["What is the most recent magic the gathering card set released?", 0.6], ["What products are the most popular with my small business customers?", 0.6]]
+
+def create_knowledge_router_ui(cache_examples=False):  
+    with gr.Row():
+        question = gr.Textbox(label="Enter your question here:")
+        temperature = gr.Slider(minimum=0, maximum=2, default=.7, label="Temperature")
+    with gr.Column():
+        reasoning_strategy = gr.Textbox(label="Reasoning Strategy")
+        reasoning = gr.Textbox(label="Reasoning")
+    
+    generate_button = gr.Button(label="Generate")
+    generate_button.click(determine_and_execute, outputs=[reasoning_strategy, reasoning], inputs=[question, temperature])
+    gr.Examples(examples=examples, fn=determine_and_execute, cache_examples=cache_examples, inputs=[question, temperature], outputs=[reasoning_strategy, reasoning])
+

modules/knowledge_retrieval/destination_chain.py

@@ -0,0 +1,49 @@
+from modules.base.chain import IChain
+from modules.base.llm_chain_config import LLMChainConfig
+from modules.knowledge_retrieval.base.knowledge_domain import KnowledgeDomain
+from typing import Dict , Any, Callable
+import os
+
+class DestinationChain(IChain):
+    """
+    DestinationChain Class
+
+    Design:
+    The DestinationChain class extends the IChain interface and provides an implementation for the 
+    run method. It follows the Liskov Substitution Principle (LSP) as it can be used wherever IChain 
+    is expected. The class also adheres to the Dependency Inversion Principle (DIP) as it depends on 
+    the abstraction (KnowledgeDomain) rather than a concrete class.
+
+    Intended Implementation:
+    The DestinationChain class serves as a wrapper around a KnowledgeDomain instance. It implements 
+    the run method from the IChain interface, which simply calls the generate_response method of the 
+    KnowledgeDomain. As such, when the run method is called with a question as input, the 
+    DestinationChain class will return a response generated by the KnowledgeDomain.
+    """
+    knowledge_domain: KnowledgeDomain
+    api_key: str = os.environ.get('OPENAI_API_KEY')
+    llm: Any
+    display: Callable
+    usage: str
+    
+    def run(self, input: str) -> str:
+        return self.knowledge_domain.generate_response(input)
+
+class DestinationChainStrategy(DestinationChain):
+    """Base class for Chain Strategies"""
+    
+    def __init__(self, config: LLMChainConfig, display: Callable, knowledge_domain: KnowledgeDomain, usage: str):
+        super().__init__(knowledge_domain=knowledge_domain, llm=config.llm_class, display=display, usage=usage)
+        self.llm = config.llm_class(temperature=config.temperature, max_tokens=config.max_tokens)
+        
+        self.usage = config.usage
+
+    def run(self, question):
+        response = self.knowledge_domain.generate_response(question)
+        self.display(response)
+        return response
+
+
+def get_chain_config(temperature: float = 0.7) -> LLMChainConfig:
+    usage = "This is the default chain model that should only be used as a last resort"
+    return LLMChainConfig(usage=usage)

modules/knowledge_retrieval/domains/business_domain.py

@@ -0,0 +1,70 @@
+from modules.base.llm_chain_config import LLMChainConfig
+from modules.knowledge_retrieval.destination_chain import DestinationChainStrategy
+from modules.knowledge_retrieval.base import KnowledgeDomain
+from loguru import logger
+from langchain import PromptTemplate, LLMChain
+from langchain.llms.openai import OpenAI
+from typing import Callable
+import pprint 
+
+
+class BusinessDomain(KnowledgeDomain):
+    """
+    BusinessDomain Class
+
+    Design:
+    This class extends the KnowledgeDomain class following the Open/Closed Principle (OCP) 
+    and provides a specific implementation for generating responses to business-related questions. 
+    Its single responsibility, as per the Single Responsibility Principle (SRP), is to generate 
+    business-related responses.
+
+    Intended Implementation:
+    The generate_response method should be able to generate accurate and helpful responses to 
+    business-related questions. The logic for generating these responses could be rule-based, 
+    or it could use a trained machine learning model.
+    """
+    def generate_response(self, question: str) -> str:
+        template_cot = """You are asked a business-related question and rather than simply guessing the right answer break down the solution into a series of steps
+        The question is {question}
+
+        Write out your step by step reasoning and after considering all of the facts and applying this reasoning write out your final answer
+        """
+        prompt = PromptTemplate(template=template_cot, input_variables=["question"])
+        llm_chain = LLMChain(prompt=prompt, llm=OpenAI(temperature=0.7, max_tokens=1500))  # assuming OpenAI is the LLM to be used
+        response_cot = llm_chain.run(question)
+        return response_cot
+
+
+class BusinessChain(DestinationChainStrategy):
+    """
+    BusinessChain Class
+
+    Design:
+    This class is a specific implementation of the ChainStrategy class.
+    It follows the Open/Closed Principle (OCP) because it extends the ChainStrategy class 
+    without modifying its behavior. It also adheres to the Dependency Inversion Principle (DIP) as it 
+    depends on the abstraction (BusinessDomain) rather than a concrete class.
+
+    Intended Implementation:
+    The BusinessChain class serves as a wrapper around a BusinessDomain instance. It implements the run 
+    method from the ChainStrategy class, which simply calls the generate_response method of the BusinessDomain.
+    As such, when the run method is called with a question as input, the BusinessChain class will return a 
+    response generated by the BusinessDomain. This response will be business-related, as the BusinessDomain is 
+    designed to generate responses to business-related questions.
+    """
+    def __init__(self, config: LLMChainConfig, display: Callable):
+        super().__init__(config=config, display=display, knowledge_domain=BusinessDomain(), usage=config.usage)
+        print("Creating Business Chain with config: ")
+        pprint.pprint(vars(config))
+
+    def run(self, question):
+        print('Using Business Chain of Thought')
+        self.display("Using 'Business Chain of Thought'")
+        response_cot = super().run(question)
+        return response_cot
+
+def get_business_chain_config(temperature: float = 0.7) -> LLMChainConfig:
+    usage = """
+    This problem is business-related and requires a business-related response or business data. In general this should be items related to the small family business.
+    """
+    return LLMChainConfig(usage=usage, temperature=temperature)

modules/knowledge_retrieval/domains/family_domain.py

@@ -0,0 +1,68 @@
+from modules.base.llm_chain_config import LLMChainConfig
+from modules.knowledge_retrieval.destination_chain import DestinationChainStrategy
+from modules.knowledge_retrieval.base import KnowledgeDomain
+from loguru import logger
+from langchain import PromptTemplate, LLMChain
+from langchain.llms.openai import OpenAI
+from typing import Callable
+import pprint 
+
+class FamilyDomain(KnowledgeDomain):
+    """
+    FamilyDomain Class
+
+    Design:
+    This class is a specific implementation of the KnowledgeDomain class, providing an 
+    implementation for generating responses to family-related questions. Following the 
+    Single Responsibility Principle (SRP), its sole responsibility is to generate family-related responses.
+
+    Intended Implementation:
+    The generate_response method should generate useful responses to family-related questions. 
+    This might involve rule-based logic or a trained machine learning model, depending on the 
+    specifics of the problem domain.
+    """
+    def generate_response(self, question: str) -> str:
+        template_cot = """You are asked a family-related question and rather than simply guessing the right answer break down the solution into a series of steps
+        The question is {question}
+
+        Write out your step by step reasoning and after considering all of the facts and applying this reasoning write out your final answer
+        """
+        prompt = PromptTemplate(template=template_cot, input_variables=["question"])
+        llm_chain = LLMChain(prompt=prompt, llm=OpenAI(temperature=0.7, max_tokens=1500))  # assuming OpenAI is the LLM to be used
+        response_cot = llm_chain.run(question)
+        return response_cot
+
+
+class FamilyChain(DestinationChainStrategy):
+    """
+    FamilyChain Class
+
+    Design:
+    This class is a specific implementation of the ChainStrategy class.
+    It follows the Open/Closed Principle (OCP) because it extends the ChainStrategy class 
+    without modifying its behavior. It also adheres to the Dependency Inversion Principle (DIP) as it 
+    depends on the abstraction (FamilyDomain) rather than a concrete class.
+
+    Intended Implementation:
+    The FamilyChain class serves as a wrapper around a FamilyDomain instance. It implements the run 
+    method from the ChainStrategy class, which simply calls the generate_response method of the FamilyDomain.
+    As such, when the run method is called with a question as input, the FamilyChain class will return a 
+    response generated by the FamilyDomain.
+    """
+    def __init__(self, config: LLMChainConfig, display: Callable):
+        super().__init__(config=config, display=display, knowledge_domain=FamilyDomain(), usage=config.usage)
+        print("Creating Family Chain with config: ")
+        pprint.pprint(vars(config))
+
+    def run(self, question):
+        print('Using Family Chain of Thought')
+        self.display("Using 'Family Chain of Thought'")
+        response_cot = super().run(question)
+        return response_cot
+
+def get_family_chain_config(temperature: float = 0.7) -> LLMChainConfig:
+    usage = """
+    This problem is family-related and the solution may be obtained by focusing on generating a coherent series 
+    of reasoning steps that lead to the final answer. The problem is related to family plans, personal matters, family relations, and general non business related questions.
+    """
+    return LLMChainConfig(usage=usage, temperature=temperature)

modules/knowledge_retrieval/domains/finance_domain.py

@@ -0,0 +1,75 @@
+from modules.base.llm_chain_config import LLMChainConfig
+from modules.knowledge_retrieval.destination_chain import DestinationChainStrategy
+from modules.knowledge_retrieval.base import KnowledgeDomain
+from loguru import logger
+from langchain import PromptTemplate, LLMChain
+from langchain.llms.openai import OpenAI
+from typing import Callable
+import pprint 
+
+class FinanceDomain(KnowledgeDomain):
+    """
+    FinanceDomain Class
+
+    Design:
+    This class is a specific implementation of the KnowledgeDomain class. It provides a specific 
+    implementation for generating responses to finance-related questions. Following the Single 
+    Responsibility Principle (SRP), its sole responsibility is to generate finance-related responses.
+
+    Intended Implementation:
+    The generate_response method should generate appropriate responses to finance-related questions. 
+    Depending on the specifics of the problem domain, this could involve a rule-based approach, 
+    using a trained machine learning model, or some other method of generating responses.
+    """
+    def generate_response(self, question: str) -> str:
+        template_cot = """You are asked a finance-related question and rather than simply guessing the right answer break down the solution into a series of steps
+        The question is {question}
+
+        Write out your step by step reasoning and after considering all of the facts and applying this reasoning write out your final answer
+        """
+        prompt = PromptTemplate(template=template_cot, input_variables=["question"])
+        llm_chain = LLMChain(prompt=prompt, llm=OpenAI(temperature=0.7, max_tokens=1500))  # assuming OpenAI is the LLM to be used
+        response_cot = llm_chain.run(question)
+        return response_cot
+
+
+class FinanceChain(DestinationChainStrategy):
+    """
+    FinanceChain Class
+
+    Design:
+    This class is a specific implementation of the ChainStrategy class.
+    It follows the Open/Closed Principle (OCP) because it extends the ChainStrategy class 
+    without modifying its behavior. It also adheres to the Dependency Inversion Principle (DIP) as it 
+    depends on the abstraction (FinanceDomain) rather than a concrete class.
+
+    Intended Implementation:
+    The FinanceChain class serves as a wrapper around a FinanceDomain instance. It implements the run 
+    method from the ChainStrategy class, which simply calls the generate_response method of the FinanceDomain.
+    As such, when the run method is called with a question as input, the FinanceChain class will return a 
+    response generated by the FinanceDomain.
+    """
+    def __init__(self, config: LLMChainConfig, display: Callable):
+        super().__init__(config=config, display=display, knowledge_domain=FinanceDomain(), usage=config.usage)
+        print("Creating Finance Chain with config: ")
+        pprint.pprint(vars(config))
+
+    def run(self, question):
+        print('Using Finance Chain of Thought')
+        self.display("Using 'Finance Chain of Thought'")
+        response_cot = super().run(question)
+        return response_cot
+
+def get_finance_chain_config(temperature: float = 0.7) -> LLMChainConfig:
+    usage = """
+    This problem is finance-related and relates to the following topics:
+    - Financial Planning
+    - Financial Analysis
+    - Financial Management
+    - Financial Markets
+    - Financial Instruments
+    - Financial Services
+
+    Or things of this nature
+    """
+    return LLMChainConfig(usage=usage, temperature=temperature)

modules/knowledge_retrieval/domains/gaming_domain.py

@@ -0,0 +1,74 @@
+from modules.base.llm_chain_config import LLMChainConfig
+from modules.knowledge_retrieval.destination_chain import DestinationChainStrategy
+from modules.knowledge_retrieval.base import KnowledgeDomain
+from loguru import logger
+from langchain import PromptTemplate, LLMChain
+from langchain.llms.openai import OpenAI
+from typing import Callable
+import pprint 
+
+class GamingDomain(KnowledgeDomain):
+    """
+    GamingDomain Class
+
+    Design:
+    This class extends the KnowledgeDomain class and provides a specific implementation for 
+    generating responses to gaming-related questions. It adheres to the Single Responsibility 
+    Principle (SRP) with its single responsibility of generating gaming-related responses.
+
+    Intended Implementation:
+    The generate_response method should generate appropriate responses to gaming-related questions. 
+    Depending on the requirements, this could involve a rule-based approach, a trained machine 
+    learning model, or some other method of generating responses.
+    """
+    def generate_response(self, question: str) -> str:
+        template_cot = """You are asked a gaming-related question and rather than simply guessing the right answer break down the solution into a series of steps
+        The question is {question}
+
+        Write out your step by step reasoning and after considering all of the facts and applying this reasoning write out your final answer
+        """
+        prompt = PromptTemplate(template=template_cot, input_variables=["question"])
+        llm_chain = LLMChain(prompt=prompt, llm=OpenAI(temperature=0.7, max_tokens=1500))  # assuming OpenAI is the LLM to be used
+        response_cot = llm_chain.run(question)
+        return response_cot
+
+
+class GamingChain(DestinationChainStrategy):
+    """
+    GamingChain Class
+
+    Design:
+    This class is a specific implementation of the ChainStrategy class.
+    It follows the Open/Closed Principle (OCP) because it extends the ChainStrategy class 
+    without modifying its behavior. It also adheres to the Dependency Inversion Principle (DIP) as it 
+    depends on the abstraction (GamingDomain) rather than a concrete class.
+
+    Intended Implementation:
+    The GamingChain class serves as a wrapper around a GamingDomain instance. It implements the run 
+    method from the ChainStrategy class, which simply calls the generate_response method of the GamingDomain.
+    As such, when the run method is called with a question as input, the GamingChain class will return a 
+    response generated by the GamingDomain.
+    """
+    def __init__(self, config: LLMChainConfig, display: Callable):
+        super().__init__(config=config, display=display, knowledge_domain=GamingDomain(), usage=config.usage)
+        print("Creating Gaming Chain with config: ")
+        pprint.pprint(vars(config))
+
+    def run(self, question):
+        print('Using Gaming Chain of Thought')
+        self.display("Using 'Gaming Chain of Thought'")
+        response_cot = super().run(question)
+        return response_cot
+
+def get_gaming_chain_config(temperature: float = 0.7) -> LLMChainConfig:
+    usage = """
+    This problem is gaming-related and related to active play and leasure that we engage in. Example topics are :
+    - What is the best way to play a game?
+    - What games do you like to play?
+    - What games have we played together?
+    - Gaming scenario generation
+    - Gaming Configurations
+
+    And related items
+    """
+    return LLMChainConfig(usage=usage, temperature=temperature)

modules/knowledge_retrieval/knowledge_router.py

@@ -0,0 +1,85 @@
+from loguru import logger
+from modules.knowledge_retrieval.domains.business_domain import BusinessChain, get_business_chain_config
+from modules.knowledge_retrieval.domains.family_domain import FamilyChain, get_family_chain_config
+from modules.knowledge_retrieval.domains.gaming_domain import GamingChain, get_gaming_chain_config
+from modules.knowledge_retrieval.domains.finance_domain import FinanceChain, get_finance_chain_config
+from modules.base.llm_chain_config import LLMChainConfig
+from modules.knowledge_retrieval.base.router_chain import RouterChain
+from modules.knowledge_retrieval.destination_chain import DestinationChainStrategy
+from langchain import PromptTemplate, LLMChain
+
+import pprint
+from typing import Callable, Dict, Optional, Tuple
+import re
+
+class KnowledgeDomainRouter(RouterChain):
+    def __init__(self, api_key: str, config: LLMChainConfig, question: str, display: Callable):
+        chains : Dict[int, DestinationChainStrategy] = {
+        1: BusinessChain(config=get_business_chain_config(), display=display),
+        2: FamilyChain(config=get_family_chain_config(), display=display),
+        3: GamingChain(config=get_gaming_chain_config(), display=display),
+        4: FinanceChain(config=get_finance_chain_config(), display=display)
+    }
+        
+        usage_block = f"""
+        1. {chains[1].usage} [1].
+        2. {chains[2].usage} [2].
+        3. {chains[3].usage} [3].
+        4. {chains[4].usage} [4].
+        """
+        template = """
+            Consider the following problem : {question}. Based on the characteristics of the problem,
+            identify the most suitable knowledge domain to query from the items provided. Consider each carefully 
+            in the context of the question, write out the likelihood of relevant of each, and then select the most 
+            appropriate knowledge domain:""" + usage_block + """
+                Based on the characteristics of the given problem , select the domain that aligns most closely with the nature of the problem. It is important to first provide the number of the technique that best solves the problem, followed by a period. Then you may provide your reason why you have chosen this technique. 
+
+            The number and name of the selected strategy is...
+            """
+
+        super().__init__(template = template, api_key = api_key, destination_chains=chains, usage=config.usage, llm=config.llm_class, question=question)
+        print("Creating Knowledge Domain Router with config: ")
+        # pprint.pprint(config)
+        self.llm = config.llm_class(temperature=config.temperature, max_tokens=config.max_tokens, api_key=api_key)
+        self.question: str = question
+
+    def run(self, question: str) -> str:
+
+
+        for index, chain in self.destination_chains.items():
+            print(f'Running Chain #{index}')
+            self.display(f"Running Chain #{index}")
+            response = chain.run(question)
+            print(response)
+            self.display(response)
+        return response
+
+
+    @staticmethod
+    def find_first_integer(text: str) -> Optional[int]:
+        match = re.search(r'\d+', text)
+        if match:
+            return int(match.group())
+        else:
+            return None
+
+    def determine_and_execute(self, question) -> Tuple[str, str]:
+        prompt = PromptTemplate(template=self.template, input_variables=["question"])
+        llm_chain = LLMChain(prompt=prompt, llm=self.llm)
+
+        response = llm_chain.run(self.question)
+        print(response)
+        self.display(response)
+        n = self.find_first_integer(response)
+
+        if n in self.destination_chains:
+            chain_resp = self.destination_chains[n].run(self.question)
+        else:
+            chain_resp = (f"Chain number {n} is not recognized.")
+            print(chain_resp)
+            
+        return response, chain_resp
+
+def get_knowledge_domain_router_config(temperature: float = 0.6) -> LLMChainConfig:
+    usage="This router should be used when determining the most effective strategy for a query requiring domain-specific knowledge to derive"
+    return LLMChainConfig(temperature=temperature, max_tokens=3000, usage=usage)

requirements.txt

@@ -4,4 +4,5 @@ gradio
 python-dotenv
 openai
 wikipedia
-ipykernel
+ipykernel
+loguru

server.py

@@ -2,6 +2,7 @@ from dotenv import load_dotenv, find_dotenv
 import os
 import gradio as gr
 from modules.reasoning.component import create_reasoning_router_ui
+from modules.knowledge_retrieval.component import create_knowledge_router_ui
 load_dotenv(find_dotenv())
 
 openai_api_key = os.getenv("OPENAI_API_KEY")
@@ -15,7 +16,7 @@ def create_interface():
         with gr.Tab("Reasoning Router"):
             create_reasoning_router_ui()
         with gr.Tab("Knowledge Domains"):
-            gr.Label("Knowledge Domains")
+            create_knowledge_router_ui()
     interface.queue()
     interface.launch(server_name="0.0.0.0", server_port=7000)