asag-rag 0.1.0__tar.gz

asag_rag-0.1.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: asag-rag
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: build>=1.5.0
+Requires-Dist: faiss-cpu>=1.14.2
+Requires-Dist: google-genai>=2.8.0
+Requires-Dist: langchain>=1.3.4
+Requires-Dist: langchain-community>=0.4.2
+Requires-Dist: langchain-huggingface>=1.2.2
+Requires-Dist: langchain-tavily>=0.2.18
+Requires-Dist: openai>=2.41.0
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: pandas>=3.0.3
+Requires-Dist: pyarrow>=24.0.0
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: rank-bm25>=0.2.2
+Requires-Dist: scikit-learn>=1.9.0
+Requires-Dist: tavily-python>=0.7.25
+Requires-Dist: transformers==4.57.6
+Requires-Dist: twine>=6.2.0
+
+# asag-rag

asag_rag-0.1.0/README.md

@@ -0,0 +1 @@
+# asag-rag

asag_rag-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "asag-rag"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "build>=1.5.0",
+    "faiss-cpu>=1.14.2",
+    "google-genai>=2.8.0",
+    "langchain>=1.3.4",
+    "langchain-community>=0.4.2",
+    "langchain-huggingface>=1.2.2",
+    "langchain-tavily>=0.2.18",
+    "openai>=2.41.0",
+    "openpyxl>=3.1.5",
+    "pandas>=3.0.3",
+    "pyarrow>=24.0.0",
+    "python-dotenv>=1.2.2",
+    "rank-bm25>=0.2.2",
+    "scikit-learn>=1.9.0",
+    "tavily-python>=0.7.25",
+    "transformers==4.57.6",
+    "twine>=6.2.0",
+]

asag_rag-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

asag_rag-0.1.0/src/asag_rag.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: asag-rag
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: build>=1.5.0
+Requires-Dist: faiss-cpu>=1.14.2
+Requires-Dist: google-genai>=2.8.0
+Requires-Dist: langchain>=1.3.4
+Requires-Dist: langchain-community>=0.4.2
+Requires-Dist: langchain-huggingface>=1.2.2
+Requires-Dist: langchain-tavily>=0.2.18
+Requires-Dist: openai>=2.41.0
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: pandas>=3.0.3
+Requires-Dist: pyarrow>=24.0.0
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: rank-bm25>=0.2.2
+Requires-Dist: scikit-learn>=1.9.0
+Requires-Dist: tavily-python>=0.7.25
+Requires-Dist: transformers==4.57.6
+Requires-Dist: twine>=6.2.0
+
+# asag-rag

asag_rag-0.1.0/src/asag_rag.egg-info/SOURCES.txt

@@ -0,0 +1,33 @@
+README.md
+pyproject.toml
+src/asag_rag.egg-info/PKG-INFO
+src/asag_rag.egg-info/SOURCES.txt
+src/asag_rag.egg-info/dependency_links.txt
+src/asag_rag.egg-info/requires.txt
+src/asag_rag.egg-info/top_level.txt
+src/rag/__init__.py
+src/rag/config.py
+src/rag/embed.py
+src/rag/generator.py
+src/rag/ingest.py
+src/rag/pipeline.py
+src/rag/prompt.py
+src/rag/retriever.py
+src/rag/splitter.py
+src/rag/ingestions/__init__.py
+src/rag/ingestions/base.py
+src/rag/ingestions/csv.py
+src/rag/ingestions/excel.py
+src/rag/ingestions/parquet.py
+src/rag/ingestions/rahutomo.py
+src/rag/llms/__init__.py
+src/rag/llms/base.py
+src/rag/llms/gemini.py
+src/rag/llms/huggingface.py
+src/rag/llms/openai.py
+src/rag/retrievers/__init__.py
+src/rag/retrievers/external.py
+src/rag/retrievers/hybrid.py
+src/rag/retrievers/local.py
+src/rag/retrievers/wrappers/__init__.py
+src/rag/retrievers/wrappers/top_k.py

asag_rag-0.1.0/src/asag_rag.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

asag_rag-0.1.0/src/asag_rag.egg-info/requires.txt

@@ -0,0 +1,17 @@
+build>=1.5.0
+faiss-cpu>=1.14.2
+google-genai>=2.8.0
+langchain>=1.3.4
+langchain-community>=0.4.2
+langchain-huggingface>=1.2.2
+langchain-tavily>=0.2.18
+openai>=2.41.0
+openpyxl>=3.1.5
+pandas>=3.0.3
+pyarrow>=24.0.0
+python-dotenv>=1.2.2
+rank-bm25>=0.2.2
+scikit-learn>=1.9.0
+tavily-python>=0.7.25
+transformers==4.57.6
+twine>=6.2.0

asag_rag-0.1.0/src/asag_rag.egg-info/top_level.txt

@@ -0,0 +1 @@
+rag

asag_rag-0.1.0/src/rag/__init__.py

@@ -0,0 +1,6 @@
+from .config import RAGConfig
+from .ingest import RAGIngest
+from .embed import RAGEmbed
+from .retriever import RAGRetriever
+from .generator import RAGGenerator
+from .pipeline import RAGPipeline

asag_rag-0.1.0/src/rag/config.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+
+@dataclass
+class RAGConfig:
+    # Chunking
+    # chunk_size: int = 512
+    # chunk_overlap: int = 64
+
+    top_k: int = 5
+    embedding_model: str = "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
+
+    llm_model: str = "gpt-4o-mini"
+    temperature: float = 0.1
+    top_p: float = 0.01
+    max_tokens: int = 1024

asag_rag-0.1.0/src/rag/embed.py

@@ -0,0 +1,33 @@
+from langchain_huggingface.embeddings import HuggingFaceEmbeddings
+from langchain_community.docstore.in_memory import InMemoryDocstore
+from langchain_community.vectorstores import FAISS
+from uuid import uuid4
+from typing import List
+from langchain_core.documents import Document
+import faiss
+
+class RAGEmbed:
+    def __init__(self, model_name: str):
+        self.model = HuggingFaceEmbeddings(model_name=model_name)
+        self.vector_store: FAISS | None = None
+
+    def build_vector_store(self, documents: List[Document]):
+        index = faiss.IndexFlatL2(len(self.model.embed_query(documents[0].page_content)))
+        self.vector_store = FAISS(
+            embedding_function=self.model,
+            index=index,
+            docstore=InMemoryDocstore(),
+            index_to_docstore_id={},
+        )
+
+    def add_documents(self, documents: List[Document]):
+        uuids = [str(uuid4()) for _ in range(len(documents))]
+        self.vector_store.add_documents(documents=documents, ids=uuids)
+
+    def load(self, path: str):
+        self.vector_store = FAISS.load_local(
+            path, self.model, allow_dangerous_deserialization=True
+        )
+
+    def save(self, path: str):
+        self.vector_store.save_local(path)

asag_rag-0.1.0/src/rag/generator.py

@@ -0,0 +1,29 @@
+from typing import Literal, List
+from langchain_core.documents import Document
+from .llms import BACKENDS
+from .llms.base import BaseLLM
+from .prompt import build_prompt, build_prompt_list
+
+class RAGGenerator:
+    def __init__(
+        self,
+        backend: Literal["huggingface", "openai", "gemini"],
+        model_name: str,
+        system_prompt: str | None = None,
+        **kwargs,
+    ):
+        self.system_prompt = system_prompt
+        self.llm: BaseLLM = self._load_backend(backend, model_name, **kwargs)
+
+    def _load_backend(self, backend: str, model_name: str, **kwargs) -> BaseLLM:
+        if backend not in BACKENDS:
+            raise ValueError(f"Unknown backend '{backend}'. Choose from: {list(BACKENDS.keys())}")
+        return BACKENDS[backend](model_name=model_name, **kwargs)
+
+    def generate(self, query: str, reference: List[str], docs: List[Document]=[], min_score=0, max_score=5) -> str:
+        question, answer = query.split("[CLS]")
+        prompt = build_prompt_list(question, answer, reference, docs, self.system_prompt, min_score, max_score)
+        return self.llm.generate(prompt)
+
+    def generate_with_prompt(self, prompt: str) -> str:
+        return self.llm.generate(prompt)

asag_rag-0.1.0/src/rag/ingest.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+from typing import List, Dict, Any
+from langchain_core.documents import Document
+from .ingestions import LOADERS, NAME_LOADERS
+from .ingestions import BaseLoader
+import pandas as pd
+
+class RAGIngest:
+    def __init__(self): 
+        self.documents = []
+        pass
+
+    def _resolve_loader(self, source: str, name: str | None, loader_kwargs: Dict[str, Any] = {}) -> BaseLoader:
+        ext = Path(source).suffix.lower()
+        if ext not in LOADERS and name not in NAME_LOADERS:
+            raise ValueError(f"Unsupported file type '{ext}'. Supported: {list(LOADERS.keys())}")
+        if name is not None:
+            return NAME_LOADERS[name](**loader_kwargs)
+        return LOADERS[ext](**loader_kwargs)
+
+    def load(
+        self,
+        source: str,
+        name: str = None,
+        loader_kwargs: Dict[str, Any] = {},
+    ):
+        loader = self._resolve_loader(source, name, loader_kwargs)
+        df = loader.load(source)
+        df['filename'] = source.split('\\')[-1]
+        return df
+    
+    def merge_df(self, dfs: List[pd.DataFrame]):
+        merged = pd.concat(dfs, ignore_index=True)
+        return merged
+    
+    def join_df(self, df1, df2, on: List[str], how='inner'):
+        if len(on) > 1:
+            join_df = pd.merge(df1, df2, how=how, left_on=on[0], right_on=on[1])
+        else:
+            join_df = pd.merge(df1, df2, how=how, on=on[0])
+        return join_df
+
+    def load_directory(self, directory: str, name: str = None, recursive: bool = True, loader_kwargs: Dict[str, Any] = {}) -> List[pd.DataFrame]:
+        """Load all supported files from a directory."""
+        root = Path(directory)
+        pattern = "**/*" if recursive else "*"
+        all_df = []
+
+        for path in root.glob(pattern):
+            if path.is_file() and path.suffix.lower() in LOADERS:
+                df = self.load(str(path), name=name, loader_kwargs=loader_kwargs)
+                all_df.append(df)
+        return all_df
+    
+    def load_processed(self, dataset_path:str):
+        """Load all processed dataset from a path"""
+
+        return pd.read_csv(dataset_path)

asag_rag-0.1.0/src/rag/ingestions/__init__.py

@@ -0,0 +1,15 @@
+from .base import BaseLoader
+from .rahutomo import RahutomoLoader
+from .excel import ExcelLoader
+from .csv import CSVDataLoader
+from .parquet import ParquetLoader
+
+LOADERS = {
+    ".parquet":  ParquetLoader,
+    ".csv":  CSVDataLoader,
+    ".xlsx": ExcelLoader,
+}
+
+NAME_LOADERS = {
+    "rahutomo": RahutomoLoader
+}

asag_rag-0.1.0/src/rag/ingestions/base.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+class BaseLoader(ABC):
+    @abstractmethod
+    def load(self, source: str):
+        """Load documents from a source path or URL."""
+        ...

asag_rag-0.1.0/src/rag/ingestions/csv.py

@@ -0,0 +1,23 @@
+from typing import List
+import pandas as pd
+from .base import BaseLoader
+
+class CSVDataLoader(BaseLoader):
+    """
+    Generic Csv loader
+    """
+    def __init__(
+        self,
+        usecols: List[str] | None = None,
+        sep: str = ","
+    ):
+        self.usecols = usecols
+        self.sep = sep
+
+    def load(self, source: str) -> pd.DataFrame:
+        df = pd.read_csv(
+            source,
+            usecols=self.usecols,
+            sep=self.sep
+        )
+        return df

asag_rag-0.1.0/src/rag/ingestions/excel.py

@@ -0,0 +1,33 @@
+import pandas as pd
+from typing import List
+from .base import BaseLoader
+
+class ExcelLoader(BaseLoader):
+    """
+    Generic Excel loader
+    """
+    def __init__(
+        self,
+        sheet_name: str | int | None = 0,
+        content_col: str | None = None,
+        usecols: List[str] | None = None,
+        skiprows: int = 0,
+    ):
+        self.sheet_name = sheet_name
+        self.content_col = content_col
+        self.usecols = usecols
+        self.skiprows = skiprows
+
+    def load(self, source: str) -> dict[str, pd.DataFrame]:
+        raw = pd.read_excel(
+            source,
+            sheet_name=self.sheet_name,
+            usecols=self.usecols,
+            skiprows=self.skiprows,
+        )
+        if isinstance(raw, pd.DataFrame):
+            sheets = {"sheet0": raw}
+        else:
+            sheets = raw
+
+        return sheets

asag_rag-0.1.0/src/rag/ingestions/parquet.py

@@ -0,0 +1,26 @@
+import pandas as pd
+from typing import List
+from .base import BaseLoader
+
+class ParquetLoader(BaseLoader):
+    """
+    Generic Parquet loader
+    """
+    def __init__(
+        self,
+        columns: List[str] | None = None,    
+        filters=None,                         
+        engine: str = "pyarrow",
+    ):
+        self.columns = columns
+        self.filters = filters
+        self.engine = engine
+
+    def load(self, source: str) -> pd.DataFrame:
+        df = pd.read_parquet(
+            source,
+            columns=self.columns,
+            filters=self.filters,
+            engine=self.engine,
+        )
+        return df

asag_rag-0.1.0/src/rag/ingestions/rahutomo.py

@@ -0,0 +1,43 @@
+import pandas as pd
+from .excel import ExcelLoader
+from typing import List
+
+class RahutomoLoader(ExcelLoader):
+    """
+    Domain-specific loader for multi-sheet exam Excel files.
+
+    Structure expected:
+    - Sheet 'Soal'   : reference with question text & answer key per row
+    - Sheet[1:-1]    : one sheet per question with candidate answer rows
+    - First column   : dropped (row numbering)
+    """
+    def __init__(self, 
+                skiprows: int = 1, 
+                usecols: List[str] | None = None,):
+        super().__init__(None, skiprows=skiprows, usecols=usecols)
+
+    def load(self, source: str) -> pd.DataFrame:
+        all_sheets = super().load(source)
+        all_sheets = {k: df.iloc[:, 1:] for k, df in all_sheets.items()}
+
+        sheet_names = list(all_sheets.keys())
+        soal_list   = sheet_names[1:-1]
+        ref_df      = all_sheets["Soal"].reset_index(drop=True)
+
+        processed = []
+        for idx, sheet_name in enumerate(soal_list):
+            data = all_sheets[sheet_name].dropna().copy()
+            data.columns = [c.strip().replace(" ", "") for c in data.columns]
+
+            if "o" in data.columns:
+                print(f"[warn] Sheet '{sheet_name}' has unexpected column 'o'")
+
+            ref_row  = ref_df.loc[idx]
+            soal_col = "Soal" if "Soal" in ref_row.index else "Soal "
+            data["Soal"] = ref_row[soal_col]
+            data["KunciJawaban"] = ref_row["Kunci Jawaban"]
+            data["SheetName"] = sheet_name
+
+            processed.append(data[["SheetName", "Soal", "KunciJawaban", "Jawaban", "Manual1", "Manual2", "Manual3"]])
+
+        return pd.concat(processed, ignore_index=True).drop_duplicates()

asag_rag-0.1.0/src/rag/llms/__init__.py

@@ -0,0 +1,9 @@
+from .huggingface import HuggingFaceLLM
+from .openai import OpenAILLM
+from .gemini import GeminiLLM
+
+BACKENDS = {
+    "huggingface": HuggingFaceLLM,
+    "openai": OpenAILLM,
+    "gemini": GeminiLLM
+}

asag_rag-0.1.0/src/rag/llms/base.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+from typing import List
+
+class BaseLLM(ABC):
+    @abstractmethod
+    def generate(self, prompt: str | List[str]) -> str:
+        """
+        Sending prompt to LLM to generate response
+
+        Input: 
+        - prompt: str | List[str] = single prompt or multiple prompt
+
+        Output:
+        - str = LLM response
+
+        """
+        ...

asag_rag-0.1.0/src/rag/llms/gemini.py

@@ -0,0 +1,32 @@
+from .base import BaseLLM
+from google.genai import Client
+from google.genai import types
+from typing import List
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+class GeminiLLM(BaseLLM):
+    """
+    Wrapper Class for Google Gemini
+    """
+    def __init__(self, model_name: str = "", temperature: float = 0.0, max_tokens: int = 512, top_p: int = 1):
+        self.client = Client(api_key=os.environ.get("GOOGLE_API_KEY"))
+        self.model_name = model_name
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.top_p = top_p
+
+    def generate(self, prompt: str | List[str]) -> str:
+        output = self.client.models.generate_content(
+            model=self.model_name,
+            contents=types.Part.from_text(text=prompt),
+            config=types.GenerateContentConfig(
+                temperature=self.temperature,
+                top_p=self.top_p,
+                max_output_tokens=self.max_tokens
+            ),
+        )
+        return output.text
+    

asag_rag-0.1.0/src/rag/llms/huggingface.py

@@ -0,0 +1,21 @@
+from .base import BaseLLM
+from transformers import pipeline
+from typing import List
+
+class HuggingFaceLLM(BaseLLM):
+    """
+    Wrapper Class for Huggingface Models
+    """
+    def __init__(self, model_name: str, max_new_tokens: int = 512, temperature: float = 0.0, device: str = "cpu"):
+        self.pipe = pipeline(
+            "text-generation",
+            model=model_name,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            device=device,
+            do_sample=temperature > 0.0,
+        )
+
+    def generate(self, prompt: str | List[str]) -> str:
+        output = self.pipe(prompt)
+        return output[0]["generated_text"][-1]['content']

asag_rag-0.1.0/src/rag/llms/openai.py

@@ -0,0 +1,24 @@
+from .base import BaseLLM
+from openai import OpenAI
+from typing import List
+
+class OpenAILLM(BaseLLM):
+    """
+    Wrapper Class for OpenAI LLM APIs
+    """
+    def __init__(self, model_name: str = "gpt-4o-mini", temperature: float = 0.0, max_tokens: int = 512, top_p: int = 1):
+        self.client = OpenAI()
+        self.model_name = model_name
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.top_p = top_p
+
+    def generate(self, prompt: str | List[str]) -> str:
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=prompt,
+            temperature=self.temperature,
+            max_tokens=self.max_tokens,
+            max_completion_tokens=self.max_tokens
+        )
+        return response.choices[0].message.content.strip()

asag_rag-0.1.0/src/rag/pipeline.py

@@ -0,0 +1,81 @@
+from .embed import RAGEmbed
+from .retriever import RAGRetriever
+from .ingest import RAGIngest
+from .config import RAGConfig
+from langchain_core.documents import Document
+from .generator import RAGGenerator
+import numpy as np
+import time
+
+class RAGPipeline:
+
+    def __init__(self, 
+                 cfg: RAGConfig, 
+                 embedding_path: str, 
+                 question_column_name: str, 
+                 reference_column_name: str,
+                 answer_column_name: str,
+                ):
+        self.embedder = RAGEmbed(model_name=cfg.embedding_model)
+        self.embedder.load(embedding_path)
+        self.ingest = RAGIngest()        
+        self.local_retriever = RAGRetriever()
+        self.question_column_name = question_column_name
+        self.reference_column_name = reference_column_name
+        self.answer_column_name = answer_column_name
+
+        system_prompt = """
+        Kamu adalah evaluator yang kritis, tegas, dan adil dalam memberikan jawaban dan menyesuaikan dengan fakta dan kriteria yang berlaku. Jika jawaban hanya berisi '-', kosong, atau tidak menjawab pertanyaan, maka berikan skor rendah menyesuaikan apa yang ditulis.
+
+        /no_think        
+        """
+        self.generator = RAGGenerator('huggingface', cfg.llm_model, system_prompt=system_prompt, temperature=cfg.temperature, max_new_tokens=cfg.max_tokens)
+
+    def load_example(self, dataset_path: str):
+        example = self.ingest.load_processed(f"{dataset_path}/example.csv")
+        self.documents = [Document(page_content = row['input'], metadata={
+            'question': row[self.question_column_name],
+            'reference_answer': row[self.reference_column_name]
+        }) for _, row in example.iterrows()]
+    
+    def retrieve(self, query):
+        res = self.local_retriever.retrieve(
+            f'{query}','local', {
+            "documents": self.documents,
+            "vector_store": self.embedder.vector_store
+        })
+        if len(res) < 1:
+            raise ValueError("Context not sufficient")
+        return res
+    
+    def run(self, data, output_folder, do_retrieve, batch_num):
+        batch_idxs = np.linspace(0, len(data[self.question_column_name]), batch_num + 1, dtype=int)
+        for idx in range(3, len(batch_idxs) - 1): 
+            scores = []
+            for i in range(batch_idxs[idx], batch_idxs[idx + 1]):
+                docs = []
+                row = data.iloc[i]
+                if do_retrieve:
+                    docs = self.retrieve(f"{row[self.question_column_name]}[CLS]{row['input']}")
+                
+                response =  self.generator.generate(
+                        f"{row[self.question_column_name]}[CLS]{row[self.answer_column_name]}", 
+                        [row[self.reference_column_name]], 
+                        docs)
+                # time.sleep(10)
+                print(response)
+                
+                scores.append(response)
+            saved = data.iloc[batch_idxs[idx]:batch_idxs[idx + 1]]
+            saved['Prediksi'] = scores
+            if do_retrieve:
+                saved.to_csv(f"{output_folder}/rag/result-{idx+1}.csv", index=False)
+            else:
+                saved.to_csv(f"{output_folder}/no-rag/result-{idx+1}.csv", index=False)
+
+    def run_train(self, dataset_path, output_folder, do_retrieve=True, batch_num:int=10):
+        self.load_example(dataset_path)
+        train = self.ingest.load_processed(f"{dataset_path}/train.csv")
+        self.run(train, output_folder, do_retrieve, batch_num)
+
+    

asag_rag-0.1.0/src/rag/prompt.py

@@ -0,0 +1,61 @@
+from typing import List
+from langchain_core.documents import Document
+
+DEFAULT_SYSTEM_PROMPT = (
+    "You are a helpful assistant. Answer the question using only the provided context. "
+    "If the answer is not in the context, say you don't know."
+)
+
+def build_prompt_list(question: str, answer: str, reference: List[str], docs: List[Document], system_prompt: str | None = None, min_score=0, max_score=5) -> str:
+    context = "\n".join(
+        f"[{i+1}] {doc.page_content}" for i, doc in enumerate(docs)
+    ) if len(docs) > 0 else ""
+    references = "\n".join(f"[{i+1}] {ref}" for i, ref in enumerate(reference))
+
+    system = system_prompt or DEFAULT_SYSTEM_PROMPT
+    return [{
+        "role": "system",
+        "content": system
+    }, {
+        "role": "user",
+        "content": (
+f"{f'Context: {context}' if context != "" else ""}"
+f"""
+Given the question and answer data, evaluate the answer and give the score in range {min_score}-{max_score} with the criterias below:
+- Answer cannot be empty or not answering the question. If that is the case, then assign {min_score}.
+- Please tailor the provided answers to the reference as closely as possible
+- If you dont understand about the answer, you can use context and reference to guide you in grading.
+
+Question: \"\"\"{question}\"\"\"
+Answer: \"\"\"{answer}\"\"\"
+{"References:\n" + references if len(reference) > 0 else ""}
+
+Generate the output with the format below:
+"""
+f"Score: <the answer's score based on reference and context in number format>")
+    }]
+
+def build_prompt(question: str, answer: str, reference: List[str], docs: List[Document], system_prompt: str | None = None, min_score=0, max_score=5) -> str:
+    context = "\n".join(
+        f"[{i+1}] {doc.page_content}" for i, doc in enumerate(docs)
+    ) if len(docs) > 0 else ""
+    references = "\n".join(f"[{i+1}] {ref}" for i, ref in enumerate(reference))
+
+    system = system_prompt or DEFAULT_SYSTEM_PROMPT
+    return (
+f"{system}\n\n"
+f"{f'Context: {context}' if context != "" else ""}"
+f"""
+Given the question and answer data, evaluate the answer and give the score in range {min_score}-{max_score} with the criterias below:
+- Answer cannot be empty or not answering the question. If that is the case, then assign {min_score}.
+- Please tailor the provided answers to the reference as closely as possible
+- If you dont understand about the answer, you can use context and reference to guide you in grading.
+
+Question: \"\"\"{question}\"\"\"
+Answer: \"\"\"{answer}\"\"\"
+{"References:\n" + references if len(reference) > 0 else ""}
+
+Generate the output with the format below:
+"""
+f"Score: <the answer's score based on reference and context in number format>"
+    )

asag_rag-0.1.0/src/rag/retriever.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+from typing import List, Dict, Any
+from src.rag.retrievers import SOURCES
+from langchain_core.retrievers import BaseRetriever
+from langchain_core.documents import Document
+
+class RAGRetriever:
+    def __init__(self):
+        pass
+
+    def _resolve_loader(self, source: str, loader_kwargs: Dict[str, Any] = {}) -> BaseRetriever:
+        if source not in SOURCES:
+            raise ValueError(f"Unsupported source '{source}'. Supported: {list(SOURCES.keys())}")
+        return SOURCES[source](**loader_kwargs)
+    
+    def retrieve(self, query: str, source: str, loader_kwargs: Dict[str, Any] = {}) -> List[Document]:
+        retriever = self._resolve_loader(source, loader_kwargs)
+        return retriever.invoke(query)
+    

asag_rag-0.1.0/src/rag/retrievers/__init__.py

@@ -0,0 +1,9 @@
+from .local import LocalRetriever
+from .external import ExternalRetriever
+from .hybrid import HybridRetriever
+
+SOURCES = {
+    "local": LocalRetriever,
+    "external": ExternalRetriever,
+    "hybrid": HybridRetriever
+}

asag_rag-0.1.0/src/rag/retrievers/external.py

@@ -0,0 +1,32 @@
+from langchain_core.retrievers import BaseRetriever
+from typing import Dict, List
+from langchain_community.retrievers import TavilySearchAPIRetriever
+from langchain_core.documents import Document
+import json
+
+class ExternalRetriever(BaseRetriever):
+    caches:Dict[str, Dict] = {}
+
+    def __init__(self, k:int=3):
+        self.tool = TavilySearchAPIRetriever(k=k)
+
+    def _get_relevant_documents(self, query: str) -> List[Document]:
+        
+        if query in self.caches.keys():
+            return self.caches[query]
+
+        result = self.tool.invoke(query.split("[CLS]")[0])
+        self.caches[query] = result
+        return result
+
+    async def _aget_relevant_documents(self, query: str) -> List[Document]:
+        return self._get_relevant_documents(query)
+    
+    def save_cache(self, path):
+        with open(path, 'w') as file:
+            json.dump(self.caches, file, indent=4)
+
+    def load_cache(self, path):
+        with open(path, 'r') as file:
+            self.caches = json.load(file)
+

asag_rag-0.1.0/src/rag/retrievers/hybrid.py

@@ -0,0 +1,16 @@
+from typing import List
+from langchain_classic.retrievers import EnsembleRetriever
+from langchain_core.retrievers import BaseRetriever
+from src.rag.retrievers.wrappers import TopKRetriever
+from langchain_core.documents import Document
+
+class HybridRetriever(BaseRetriever):
+
+    def __init__(self, retrievers:List, weights:List):
+        self.retriever = TopKRetriever(EnsembleRetriever(retrievers=retrievers, weights=weights))
+
+    def _get_relevant_documents(self, query) -> List[Document]:
+        return self.retriever.invoke(query)
+    
+    async def _aget_relevant_documents(self, query: str) -> List[Document]:
+        return self._get_relevant_documents(query)

asag_rag-0.1.0/src/rag/retrievers/local.py

@@ -0,0 +1,53 @@
+from langchain_community.retrievers import BM25Retriever
+from langchain_classic.retrievers import EnsembleRetriever
+from langchain_community.vectorstores import FAISS
+from langchain_core.documents import Document
+from langchain_core.retrievers import BaseRetriever
+from typing import List
+from pydantic import Field
+
+class LocalRetriever(BaseRetriever):
+    vector_store: FAISS = Field(...)          
+    documents: List[Document] = Field(...)
+
+    def vector_search(self, query: str, question: str, top_n: int = 3):
+        retriever = self.vector_store.as_retriever(
+            search_kwargs={"filter": {"question": question}}
+        )
+        return retriever.invoke(query)
+    
+    def _get_relevant_documents(self, query: str) -> List[Document]:
+        question, answer = query.split('[CLS]')
+        return self.ensemble_search(answer, question)
+        
+    async def _aget_relevant_documents(self, query: str) -> List[Document]:
+        return self._get_relevant_documents(query)
+
+    def ensemble_search(self, query: str, question: str, alpha: float = 0.5, beta: float = 0.5):
+        faiss_retriever = self.vector_store.as_retriever(
+            search_kwargs={"filter": {"question": question}}
+        )
+        bm25_retriever = BM25Retriever.from_documents(
+            [d for d in self.documents if d.metadata.get("question") == question]
+        )
+        ensemble = EnsembleRetriever(
+            retrievers=[bm25_retriever, faiss_retriever],
+            weights=[alpha, beta]
+        )
+        return ensemble.invoke(query)
+    
+    def get_ensemble_retriever(self, question, top_n, alpha=0.5, beta=0.5):
+        self.faiss_retriever = self.vector_store.as_retriever(
+            search_kwargs={
+                "k": top_n,
+                "filter": {
+                    'question': question
+                }
+            },
+        )
+        self.bm25_retriever = BM25Retriever.from_documents([d for d in self.documents if d.metadata.get('question') == question])
+        ensemble_retriever = EnsembleRetriever(
+            retrievers=[self.bm25_retriever, self.faiss_retriever],
+            weights=[alpha, beta]
+        )
+        return ensemble_retriever

asag_rag-0.1.0/src/rag/retrievers/wrappers/__init__.py

@@ -0,0 +1 @@
+from .top_k import TopKRetriever

asag_rag-0.1.0/src/rag/retrievers/wrappers/top_k.py

@@ -0,0 +1,24 @@
+from langchain_core.retrievers import BaseRetriever
+from langchain_core.documents import Document
+from langchain_core.callbacks import CallbackManagerForRetrieverRun
+from typing import List, Any
+
+class TopKRetriever(BaseRetriever):
+    """Get top 3 for any retriever."""
+
+    retriever: Any
+    top_k: int = 3
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def _get_relevant_documents(
+        self,
+        query: str,
+        *,
+        run_manager: CallbackManagerForRetrieverRun = None
+    ) -> List[Document]:
+        return self.retriever.invoke(query)[:self.top_k]
+
+    async def _aget_relevant_documents(self, query: str) -> List[Document]:
+        return self._get_relevant_documents(query)

asag_rag-0.1.0/src/rag/splitter.py

@@ -0,0 +1,66 @@
+import pandas as pd
+from typing import List
+
+class Splitter:
+    """
+        Wrapper class to split dataset into train and test
+    """
+    def __init__(self, test_size: float, temp_size: float=0):
+        self.test_size = test_size
+        self.temp_size = temp_size
+
+    def split_many(self, df_list: List[pd.DataFrame], split_column):
+        train_df = []
+        test_df = []
+        val_df = []
+        for df in df_list:
+            dataset = self.split(df, split_column)
+            if len(dataset) <= 2:
+                train_df += dataset[0]
+                test_df += dataset[1]
+            else:
+                train_df += dataset[0]
+                val_df += dataset[1]
+                test_df += dataset[2]
+        if self.temp_size > 0:
+            return pd.concat(train_df, ignore_index=True), pd.concat(val_df, ignore_index=True), pd.concat(test_df, ignore_index=True)
+        else:
+            return pd.concat(train_df, ignore_index=True), pd.concat(test_df, ignore_index=True)
+        
+    def split(self, data: pd.DataFrame, split_column: str):
+        if self.temp_size > 0:
+            train_df = []
+            test_df = []
+            val_df = []
+
+            keys = data[split_column].unique()
+            for key in keys:
+                tobe_split = data[data[split_column] == key]
+                tobe_split = tobe_split.sample(frac=1, random_state=42).reset_index(drop=True)
+                idx = -1 * int(self.test_size * len(tobe_split))
+                temp_data = tobe_split[idx:]
+                test_data = temp_data[:int(self.temp_size * len(temp_data))]
+                val_data = temp_data[int(self.temp_size * len(temp_data)):]
+                
+                train_data = tobe_split[:idx]
+
+                train_df.append(train_data)
+                test_df.append(test_data)
+                val_df.append(val_data)
+            
+            return train_df, val_df, test_df
+        else: 
+            train_df = []
+            test_df = []
+
+            keys = data[split_column].unique()
+            for key in keys:
+                tobe_split = data[data[split_column] == key]
+                tobe_split = tobe_split.sample(frac=1, random_state=42).reset_index(drop=True)
+                idx = -1 * int(self.test_size * len(tobe_split))
+                test_data = tobe_split[idx:]
+                train_data = tobe_split[:idx]
+                train_df.append(train_data)
+                test_df.append(test_data)
+            
+            return train_df, test_df