Auto-update from GitHub Actions

README.md

@@ -1,12 +1 @@
----
-license: mit
-title: AI_Research_Buddy
-sdk: gradio
-emoji: 🔥
-colorFrom: green
-colorTo: blue
-pinned: true
-short_description: Your Research Sidekick
-sdk_version: 5.17.1
----
 # AI_Research_Buddy

hf_space/hf_space/AI_Reaserch_Buddy/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

hf_space/hf_space/AI_Reaserch_Buddy/README.md

@@ -0,0 +1,14 @@
+---
+title: AI Reaserch Buddy
+emoji: 💬
+colorFrom: yellow
+colorTo: purple
+sdk: gradio
+sdk_version: 5.0.1
+app_file: app.py
+pinned: false
+license: mit
+short_description: Your Research Sidekick
+---
+
+An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).

hf_space/hf_space/AI_Reaserch_Buddy/app.py

@@ -0,0 +1,64 @@
+import gradio as gr
+from huggingface_hub import InferenceClient
+
+"""
+For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+"""
+client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+
+
+def respond(
+    message,
+    history: list[tuple[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+):
+    messages = [{"role": "system", "content": system_message}]
+
+    for val in history:
+        if val[0]:
+            messages.append({"role": "user", "content": val[0]})
+        if val[1]:
+            messages.append({"role": "assistant", "content": val[1]})
+
+    messages.append({"role": "user", "content": message})
+
+    response = ""
+
+    for message in client.chat_completion(
+        messages,
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+    ):
+        token = message.choices[0].delta.content
+
+        response += token
+        yield response
+
+
+"""
+For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
+"""
+demo = gr.ChatInterface(
+    respond,
+    additional_inputs=[
+        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
+        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(
+            minimum=0.1,
+            maximum=1.0,
+            value=0.95,
+            step=0.05,
+            label="Top-p (nucleus sampling)",
+        ),
+    ],
+)
+
+
+if __name__ == "__main__":
+    demo.launch()

hf_space/hf_space/AI_Reaserch_Buddy/requirements.txt

@@ -0,0 +1 @@
+huggingface_hub==0.25.2

hf_space/hf_space/hf_space/.github/workflows/deploy.yml

@@ -0,0 +1,26 @@
+name: Deploy to Hugging Face Space
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v3
+
+      - name: Push to Hugging Face
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          git config --global user.email "[email protected]"
+          git config --global user.name "your-github-username"
+          git clone https://user:[email protected]/spaces/Nithin89/AI_Research_Buddy hf_space
+          rsync -av --exclude '.git' . hf_space/
+          cd hf_space
+          git add .
+          git commit -m "Auto-update from GitHub Actions" || echo "No changes to commit"
+          git push origin main

hf_space/hf_space/hf_space/.gitignore

@@ -0,0 +1,171 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+chroma_db/
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc

hf_space/hf_space/hf_space/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nithin8919
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hf_space/hf_space/hf_space/README.md

@@ -1,14 +1 @@
----
-title: AI Research Buddy
-emoji: 🔥
-colorFrom: indigo
-colorTo: pink
-sdk: gradio
-sdk_version: 5.17.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: Your Research Sidekick
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AI_Research_Buddy

hf_space/hf_space/hf_space/ai_research_buddy/research_buddy.py

@@ -0,0 +1,35 @@
+import random
+from src.data_ingestion import DataIngestion
+from src.RAG import RetrievalModule
+from src.AI_agent import ResearchAgent
+from src.logger import logger
+
+class ResearchBuddyPipeline:
+    def __init__(self, config):
+        self.config = config
+        self.ingestor = DataIngestion(self.config["api_url"])
+        self.retriever = RetrievalModule(self.config["embedding_model"], self.config["persist_dir"])
+        self.agent = ResearchAgent(self.config["summarizer_model"])
+        self.openers = [
+            "Hold my coffee, I’m diving into this!",
+            "Time to unleash my inner paper monster!",
+            "Buckle up, we’re raiding the research jungle!",
+            "Let’s crank this up to eleven—here we go!"
+        ]
+
+    def process_query(self, topic, query):
+        opener = random.choice(self.openers)
+        logger.info(f"Processing query for topic: {topic}")
+
+        titles, abstracts = self.ingestor.fetch_papers(topic, self.config["max_results"])
+        if not abstracts:
+            return f"{opener}\n\nNo research found for '{topic}'. Try a different topic?"
+        
+        summaries = self.agent.summarize_papers(abstracts)
+        self.retriever.build_vector_store(summaries)
+        relevant_papers = self.retriever.retrieve_relevant(query, k=self.config["top_k"])
+
+        if not relevant_papers:
+            return f"{opener}\n\nNo relevant results for '{query}'. Try refining your query?"
+        
+        return f"{opener}\n\n" + self.agent.chat_response(None, relevant_papers, topic, query)

hf_space/hf_space/hf_space/app.py

@@ -0,0 +1,146 @@
+import gradio as gr
+import requests
+import xml.etree.ElementTree as ET
+from langchain.vectorstores import Chroma
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.memory import ConversationBufferMemory
+from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
+from loguru import logger
+import numpy as np
+
+# --- DataIngestion Class with Query Expansion ---
+class DataIngestion:
+    def __init__(self, api_url="http://export.arxiv.org/api/query"):
+        self.api_url = api_url
+        self.synonyms = {
+            "RAG": "Retrieval-Augmented Generation",
+            "AI": "Artificial Intelligence",
+            "ML": "Machine Learning"
+        }
+
+    def expand_query(self, query):
+        expanded = query
+        for key, value in self.synonyms.items():
+            if key.lower() in query.lower():
+                expanded += f" OR {value}"
+        logger.info(f"Expanded query: {expanded}")
+        return expanded
+
+    def fetch_papers(self, topic, max_results=5):
+        expanded_query = self.expand_query(topic)
+        url = f"{self.api_url}?search_query=ti:{expanded_query}+OR+ab:{expanded_query}&start=0&max_results={max_results}"
+        logger.info(f"Fetching papers from: {url}")
+        try:
+            response = requests.get(url, timeout=10)
+            response.raise_for_status()
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error fetching papers: {e}")
+            return [], [], []
+        root = ET.fromstring(response.text)
+        titles, abstracts, paper_ids = [], [], []
+        for entry in root.findall("{http://www.w3.org/2005/Atom}entry"):
+            title = entry.find("{http://www.w3.org/2005/Atom}title").text.strip()
+            abstract = entry.find("{http://www.w3.org/2005/Atom}summary").text.strip()
+            paper_id_elem = entry.find("{http://www.w3.org/2005/Atom}id")
+            paper_id = paper_id_elem.text.split("abs/")[-1].strip() if paper_id_elem is not None else "unknown"
+            titles.append(title)
+            abstracts.append(abstract)
+            paper_ids.append(paper_id)
+        logger.info(f"Fetched {len(abstracts)} papers.")
+        return titles, abstracts, paper_ids
+
+# --- RetrievalModule Class with Reranking ---
+class RetrievalModule:
+    def __init__(self, embedding_model="all-MiniLM-L6-v2", persist_dir="./chroma_db"):
+        self.embeddings = HuggingFaceEmbeddings(model_name=embedding_model)
+        self.vector_store = None
+        self.persist_dir = persist_dir
+        self.reranker_model = AutoModelForSequenceClassification.from_pretrained("cross-encoder/ms-marco-MiniLM-L-6-v2")
+        self.reranker_tokenizer = AutoTokenizer.from_pretrained("cross-encoder/ms-marco-MiniLM-L-6-v2")
+
+    def build_vector_store(self, abstracts, titles, paper_ids):
+        if not abstracts:
+            logger.warning("No abstracts provided. Skipping vector store creation.")
+            return
+        metadatas = [{"title": title, "paper_id": pid} for title, pid in zip(titles, paper_ids)]
+        self.vector_store = Chroma.from_texts(
+            texts=abstracts, embedding=self.embeddings, metadatas=metadatas, persist_directory=self.persist_dir
+        )
+        self.vector_store.persist()
+        logger.info("Chroma vector store built.")
+
+    def rerank(self, query, retrieved):
+        if not retrieved:
+            return retrieved
+        inputs = [f"{query} [SEP] {doc[0]}" for doc in retrieved]
+        tokenized = self.reranker_tokenizer(inputs, return_tensors="pt", padding=True, truncation=True, max_length=512)
+        scores = self.reranker_model(**tokenized).logits.squeeze().detach().numpy()
+        ranked_indices = np.argsort(scores)[::-1]
+        return [retrieved[i] for i in ranked_indices[:3]]
+
+    def retrieve_relevant(self, query, k=5):
+        if not self.vector_store:
+            logger.warning("Vector store empty. Run `build_vector_store` first.")
+            return []
+        top_docs = self.vector_store.similarity_search(query, k=k)
+        retrieved = [(doc.page_content, doc.metadata) for doc in top_docs]
+        reranked = self.rerank(query, retrieved)
+        logger.info(f"Retrieved and reranked {len(reranked)} papers for query: '{query}'.")
+        return reranked
+
+# --- Main Application Logic ---
+data_ingestion = DataIngestion()
+retrieval_module = RetrievalModule()
+generator = pipeline("text-generation", model="distilgpt2")
+memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+
+def process_query(query):
+    """Retrieve and summarize the best papers with their sources."""
+    try:
+        # Check chat history for follow-up context
+        history = memory.load_memory_variables({})["chat_history"]
+        if history and "more" in query.lower():
+            last_output = history[-1]["content"] if history else ""
+            context = "\n".join([line for line in last_output.split("\n") if "Summary" in line])
+        else:
+            # Fetch and retrieve papers for new query
+            titles, abstracts, paper_ids = data_ingestion.fetch_papers(query)
+            if not abstracts:
+                return "No papers found after query expansion."
+            retrieval_module.build_vector_store(abstracts, titles, paper_ids)
+            retrieved = retrieval_module.retrieve_relevant(query)
+            if not retrieved:
+                return "No relevant papers retrieved."
+            retrieved_abstracts = [item[0] for item in retrieved]
+            retrieved_metadata = [item[1] for item in retrieved]
+            context = "\n".join(retrieved_abstracts)
+            memory.save_context({"input": "Retrieved papers"}, {"output": context})
+
+        # Generate a concise summary of the best papers
+        prompt = f"Summarize the best research papers on {query} based on these abstracts:\n{context}"
+        summary = generator(prompt, max_new_tokens=100, num_return_sequences=1, truncation=True)[0]["generated_text"]
+        
+        # Include sources if not a follow-up
+        if "more" not in query.lower():
+            papers_ref = "\n".join([f"- {m['title']} ([link](https://export.arxiv.org/abs/{m['paper_id']}))" for m in retrieved_metadata])
+            full_output = f"📜 **Summary of Best Papers on {query}:**\n{summary}\n\n**Sources:**\n{papers_ref}"
+        else:
+            full_output = f"📜 **More on {query}:**\n{summary}"
+
+        memory.save_context({"input": query}, {"output": full_output})
+        return full_output
+
+    except Exception as e:
+        logger.error(f"Error: {str(e)}")
+        return f"Error: {str(e)}"
+
+# --- Gradio Interface ---
+demo = gr.Interface(
+    fn=process_query,
+    inputs=gr.Textbox(label="Enter your research query (e.g., 'RAG' or 'Tell me more')"),
+    outputs=gr.Textbox(label="Result"),
+    title="Conversational RAG Demo",
+    description="Retrieve summaries of the best papers on your topic with their sources. Ask follow-ups like 'Tell me more.'"
+)
+
+demo.launch()

hf_space/hf_space/hf_space/config.yaml

@@ -0,0 +1,6 @@
+api_url: "http://export.arxiv.org/api/query"
+embedding_model: "all-MiniLM-L6-v2"
+summarizer_model: "facebook/bart-large-cnn"
+max_results: 5
+top_k: 2
+persist_dir: "./chroma_db"

hf_space/hf_space/hf_space/hf_space/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

hf_space/hf_space/hf_space/hf_space/README.md

@@ -0,0 +1,14 @@
+---
+title: AI Research Buddy
+emoji: 🔥
+colorFrom: indigo
+colorTo: pink
+sdk: gradio
+sdk_version: 5.17.1
+app_file: app.py
+pinned: false
+license: mit
+short_description: Your Research Sidekick
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

hf_space/hf_space/hf_space/requirements.txt

@@ -0,0 +1,10 @@
+gradio
+requests
+langchain
+langchain-community
+transformers
+huggingface-hub
+loguru
+numpy
+torch
+

hf_space/hf_space/hf_space/setup.py

@@ -0,0 +1,29 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="ai_research_buddy",
+    version="0.1.0",
+    author="Nithin",
+    author_email="[email protected]",
+    description="An AI-powered research assistant using RAG, FAISS, LangChain, and Transformers.",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/Nithin8919/AI_Research_Buddy",
+    packages=find_packages(),
+    install_requires=[
+        "requests",
+        "langchain",
+        "faiss-cpu",
+        "transformers",
+        "torch",
+        "sentence-transformers",
+        "langchain_community",
+        "faiss-cpu",
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+)

hf_space/hf_space/hf_space/src/AI_agent.py

@@ -0,0 +1,141 @@
+# AI_agent.py
+from langchain_community.llms import LlamaCpp
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+from langchain.memory import ConversationBufferMemory
+from src.data_ingestion import DataIngestion
+from src.RAG import RetrievalModule
+from transformers import pipeline
+import sqlite3
+import time
+from src.logger import logger
+
+# Load LLaMA with llama.cpp—simple chatter
+llm = LlamaCpp(
+    model_path="/Users/nitin/Downloads/llama-2-7b-chat.Q4_0.gguf",  # Update this!
+    n_ctx=512,  # Fits 8 GB
+    n_threads=4,  # Fast on M3 Pro
+    temperature=0.7,
+    max_tokens=150,
+    verbose=True
+)
+
+# Instances
+data_ingestion = DataIngestion()
+retrieval_module = RetrievalModule()
+
+# Memory
+memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+
+# Database Setup
+conn = sqlite3.connect("research_data.db")
+cursor = conn.cursor()
+cursor.execute(
+    """
+    CREATE TABLE IF NOT EXISTS papers (
+        query TEXT,
+        retrieved_papers TEXT,
+        summary TEXT,
+        evaluation TEXT
+    )
+    """
+)
+conn.commit()
+
+# Tools (just functions now)
+def retrieve_relevant_papers(topic: str) -> str:
+    """Fetch and retrieve relevant papers."""
+    titles, abstracts = data_ingestion.fetch_papers(topic)
+    if not abstracts:
+        logger.warning(f"No papers retrieved for topic: {topic}")
+        return "Could not retrieve papers."
+    retrieval_module.build_vector_store(abstracts)
+    relevant_sections = retrieval_module.retrieve_relevant(topic)
+    logger.info(f"Retrieved {len(relevant_sections)} relevant papers for {topic}")
+    return "\n".join(relevant_sections)
+
+def summarize_text(text: str) -> str:
+    """Summarize text using DistilBART."""
+    summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-6-6", device="mps")
+    text = text[:500]  # Keep it short
+    summary = summarizer(text, max_length=150, min_length=50, do_sample=False)[0]["summary_text"]
+    logger.info("Generated summary for retrieved papers")
+    return summary
+
+def evaluate_summary(summary: str) -> str:
+    """Evaluate summary quality with LLaMA."""
+    prompt = f"Evaluate this summary for accuracy, completeness, and clarity: {summary[:200]}"
+    evaluation = llm(prompt)
+    logger.info("Evaluated summary quality")
+    return evaluation
+
+# Simple Conversational Chain—no retriever needed
+class ResearchAssistant:
+    def __init__(self):
+        self.prompt = PromptTemplate(
+            input_variables=["chat_history", "query"],
+            template="You are a research assistant. Based on the chat history and query, provide a helpful response.\n\nChat History: {chat_history}\nQuery: {query}\n\nResponse: "
+        )
+        self.chain = LLMChain(llm=llm, prompt=self.prompt, memory=memory)
+
+    def process_query(self, query: str) -> tuple:
+        """Process query with retries—no ReAct mess."""
+        retries = 0
+        max_retries = 3
+
+        while retries < max_retries:
+            try:
+                # Step 1: Retrieve papers
+                retrieved_papers = retrieve_relevant_papers(query)
+                if "Could not retrieve papers" in retrieved_papers:
+                    query = f"more detailed {query}"
+                    retries += 1
+                    time.sleep(2)
+                    continue
+
+                # Step 2: Summarize
+                summary = summarize_text(retrieved_papers)
+                if len(summary.split()) < 10:
+                    retries += 1
+                    time.sleep(2)
+                    continue
+
+                # Step 3: Evaluate
+                evaluation = evaluate_summary(summary)
+
+                # Save to memory and DB
+                memory.save_context(
+                    {"input": query},
+                    {"output": f"Summary: {summary}\nEvaluation: {evaluation}\nAsk me anything about these findings!"}
+                )
+                cursor.execute(
+                    "INSERT INTO papers (query, retrieved_papers, summary, evaluation) VALUES (?, ?, ?, ?)",
+                    (query, retrieved_papers, summary, evaluation)
+                )
+                conn.commit()
+                return summary, evaluation
+
+            except Exception as e:
+                logger.error(f"Error in processing: {str(e)}")
+                retries += 1
+                time.sleep(2)
+
+        logger.error("Max retries reached—task failed.")
+        return "Failed after retries.", "N/A"
+
+    def chat(self, user_input: str) -> str:
+        """Handle follow-up chats."""
+        if not memory.chat_memory.messages:
+            return "Please start with a research query like 'large language model memory optimization'."
+        return self.chain.run(query=user_input)
+
+if __name__ == "__main__":
+    assistant = ResearchAssistant()
+    query = "large language model memory optimization"
+    summary, evaluation = assistant.process_query(query)
+    print("Summary:", summary)
+    print("Evaluation:", evaluation)
+    # Test follow-up
+    follow_up = "Tell me more about memory optimization."
+    print("Follow-up:", assistant.chat(follow_up))
+    conn.close()

hf_space/hf_space/hf_space/src/RAG.py

@@ -0,0 +1,33 @@
+from langchain.vectorstores import Chroma
+from langchain.embeddings import HuggingFaceEmbeddings
+from src.logger import logger
+
+class RetrievalModule:
+    def __init__(self, embedding_model="all-MiniLM-L6-v2", persist_dir="./chroma_db"):
+        self.embeddings = HuggingFaceEmbeddings(model_name=embedding_model)
+        self.vector_store = None
+        self.persist_dir = persist_dir  # Persistent storage
+
+    def build_vector_store(self, texts):
+        """Build Chroma vector store with better logging."""
+        if not texts:
+            logger.warning("No texts provided. Skipping vector store creation.")
+            return
+        
+        self.vector_store = Chroma.from_texts(
+            texts, self.embeddings, persist_directory=self.persist_dir
+        )
+        self.vector_store.persist()
+        logger.info("Chroma vector store successfully built.")
+
+    def retrieve_relevant(self, query, k=2):
+        """Fetch top-k relevant documents, logging warnings if store is empty."""
+        if not self.vector_store:
+            logger.warning("Vector store is empty. Run `build_vector_store` first.")
+            return []
+        
+        top_docs = self.vector_store.similarity_search(query, k=k)
+        retrieved = [doc.page_content for doc in top_docs] if top_docs else []
+        
+        logger.info(f"Retrieved {len(retrieved)} relevant papers for query: '{query}'.")
+        return retrieved

hf_space/hf_space/hf_space/src/data_ingestion.py

@@ -0,0 +1,32 @@
+import requests
+import xml.etree.ElementTree as ET
+from src.logger import logger
+
+class DataIngestion:
+    def __init__(self, api_url="http://export.arxiv.org/api/query"):
+        self.api_url = api_url
+
+    def fetch_papers(self, topic, max_results=5):
+        """Fetch papers from arXiv with logging and better error handling."""
+        url = f"{self.api_url}?search_query=all:{topic}&start=0&max_results={max_results}"
+        logger.info(f"Fetching papers from: {url}")
+        
+        try:
+            response = requests.get(url, timeout=10)  # Added timeout
+            response.raise_for_status()
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error fetching papers: {e}")
+            return [], []
+        
+        # Parse XML
+        root = ET.fromstring(response.text)
+        titles, abstracts = [], []
+        
+        for entry in root.findall("{http://www.w3.org/2005/Atom}entry"):
+            title = entry.find("{http://www.w3.org/2005/Atom}title").text.strip()
+            abstract = entry.find("{http://www.w3.org/2005/Atom}summary").text.strip()
+            titles.append(title)
+            abstracts.append(abstract)
+        
+        logger.info(f"Fetched {len(abstracts)} papers.")
+        return titles, abstracts

hf_space/hf_space/hf_space/src/logger.py

@@ -0,0 +1,13 @@
+import logging
+import os
+
+LOG_FILE = "logs/research_buddy.log"
+os.makedirs(os.path.dirname(LOG_FILE), exist_ok=True)
+
+logging.basicConfig(
+    filename=LOG_FILE,
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+
+logger = logging.getLogger(__name__)

hf_space/hf_space/hf_space/src/query_enhancer.py

@@ -0,0 +1,36 @@
+# query_enhancer.py
+from llama_cpp import Llama
+
+class QueryEnhancer:
+    def __init__(self, model_path="TheBloke/Llama-2-7B-Chat-GGUF", model_file="llama-2-7b-chat.Q4_0.gguf"):
+        """Load LLaMA model with llama.cpp for query enhancement."""
+        try:
+            self.model = Llama(
+                model_path=f"{model_path}/{model_file}",  # Full path or download manually
+                n_ctx=512,  # Context length—keep it small for 8 GB
+                n_threads=4  # Use 4 CPU threads—fast on M3 Pro
+            )
+            print("LLaMA-2-7B loaded successfully with llama.cpp.")
+        except Exception as e:
+            raise RuntimeError(f"Failed to load LLaMA-2-7B: {str(e)}")
+    
+    def enhance_query(self, user_query):
+        """Refine user queries for arXiv search."""
+        prompt = (
+            f"You are a research assistant. Improve this search query for better research paper results:\n"
+            f"Original: {user_query}\n"
+            f"Refined: "
+        )
+        result = self.model(
+            prompt,
+            max_tokens=50,
+            temperature=0.7,
+            stop=["\n"]  # Stop at newline for clean output
+        )
+        refined_query = result["choices"][0]["text"].strip()
+        return refined_query
+
+if __name__ == "__main__":
+    # Manually download model to local path if needed
+    enhancer = QueryEnhancer(model_path="Downloads/llama-2-7b-chat.Q4_0.gguf ~/models/", model_file="llama-2-7b-chat.Q4_0.gguf")
+    print("Enhanced Query:", enhancer.enhance_query("AI in healthcare"))

hf_space/hf_space/hf_space/test.ipynb

@@ -0,0 +1,286 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import requests\n",
+    "url = \"http://export.arxiv.org/api/query?search_query=all:deep+learning&start=0&max_results=5\"\n",
+    "response = requests.get(url)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import xml.etree.ElementTree as ET\n",
+    "\n",
+    "# Parse the XML response\n",
+    "root = ET.fromstring(response.text)\n",
+    "\n",
+    "# Extract titles and abstracts\n",
+    "abstracts = []  # List to store abstracts\n",
+    "titles = []  # List to store titles\n",
+    "\n",
+    "for entry in root.findall(\"{http://www.w3.org/2005/Atom}entry\"):\n",
+    "    title = entry.find(\"{http://www.w3.org/2005/Atom}title\").text.strip()\n",
+    "    abstract = entry.find(\"{http://www.w3.org/2005/Atom}summary\").text.strip()\n",
+    "\n",
+    "    titles.append(title)\n",
+    "    abstracts.append(abstract)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/nitin/Documents/AI Agent project/.venv/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "Device set to use mps:0\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import pipeline\n",
+    "# Initialize summarization pipeline\n",
+    "summarizer = pipeline(\"summarization\", model=\"facebook/bart-large-cnn\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Asking to truncate to max_length but no maximum length is provided and the model has no predefined maximum length. Default to no truncation.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Title: Opening the black box of deep learning\n",
+      "Summary: The great success of deep learning shows that its technology contains aprofound truth. Understanding its internal mechanism not only has important implications for the development of its technology and effective application in various fields. At present, most of the theoretical research on\n",
+      "--------------------------------------------------------------------------------\n",
+      "Title: Concept-Oriented Deep Learning\n",
+      "Summary: Concepts are the foundation of human deep learning, understanding, and knowledge integration and transfer. We propose concept-oriented deep learning(CODL) which extends (machine) deep learning with concept representations. CODL addresses some\n",
+      "--------------------------------------------------------------------------------\n",
+      "Title: Deep learning research landscape & roadmap in a nutshell: past, present\n",
+      "  and future -- Towards deep cortical learning\n",
+      "Summary: The past, present and future of deep learning is presented in this work. We predict that deep cortical learning will be the convergence of deeplearning & cortical learning which builds an artificial cortical column.\n",
+      "--------------------------------------------------------------------------------\n",
+      "Title: A First Look at Deep Learning Apps on Smartphones\n",
+      "Summary: First empirical study on 16,500 popular Android apps. Demystifies how smartphone apps exploit deep learning in the wild. Findings paint promising picture of deep learning for smartphones.\n",
+      "--------------------------------------------------------------------------------\n",
+      "Title: Geometrization of deep networks for the interpretability of deep\n",
+      "  learning systems\n",
+      "Summary: Geometrization is a bridge to connect physics, geometry, deep networkand quantum computation. This may result in a new scheme to reveal the rule of the physical world. It may also help to solve theinterpretability problem of deep\n",
+      "--------------------------------------------------------------------------------\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Summarize abstracts\n",
+    "summaries = [summarizer(abs, max_length=50, min_length=25, truncation=True)[0][\"summary_text\"] for abs in abstracts]\n",
+    "\n",
+    "# Print results\n",
+    "for title, summary in zip(titles, summaries):\n",
+    "    print(f\"Title: {title}\\nSummary: {summary}\\n\" + \"-\"*80)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/cv/01jc2kcx1455j48m7hhwcvqw0000gn/T/ipykernel_17287/3038899353.py:4: LangChainDeprecationWarning: The class `HuggingFaceEmbeddings` was deprecated in LangChain 0.2.2 and will be removed in 1.0. An updated version of the class exists in the :class:`~langchain-huggingface package and should be used instead. To use it run `pip install -U :class:`~langchain-huggingface` and import as `from :class:`~langchain_huggingface import HuggingFaceEmbeddings``.\n",
+      "  embedding_model = HuggingFaceEmbeddings(model_name=\"sentence-transformers/all-MiniLM-L6-v2\")\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Top 1 Result:\n",
+      "We are in the dawn of deep learning explosion for smartphones. To bridge the\n",
+      "gap between research and practice, we present the first empirical study on\n",
+      "16,500 the most popular Android apps, demystifying how smartphone apps exploit\n",
+      "deep learning in the wild. To this end, we build a new static tool that\n",
+      "dissects apps and analyzes their deep learning functions. Our study answers\n",
+      "threefold questions: what are the early adopter apps of deep learning, what do\n",
+      "they use deep learning for, and how do their deep learning models look like.\n",
+      "Our study has strong implications for app developers, smartphone vendors, and\n",
+      "deep learning R\\&D. On one hand, our findings paint a promising picture of deep\n",
+      "learning for smartphones, showing the prosperity of mobile deep learning\n",
+      "frameworks as well as the prosperity of apps building their cores atop deep\n",
+      "learning. On the other hand, our findings urge optimizations on deep learning\n",
+      "models deployed on smartphones, the protection of these models, and validation\n",
+      "of research ideas on these models.\n",
+      "--------------------------------------------------------------------------------\n",
+      "Top 2 Result:\n",
+      "The past, present and future of deep learning is presented in this work.\n",
+      "Given this landscape & roadmap, we predict that deep cortical learning will be\n",
+      "the convergence of deep learning & cortical learning which builds an artificial\n",
+      "cortical column ultimately.\n",
+      "--------------------------------------------------------------------------------\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.vectorstores import FAISS\n",
+    "from langchain.embeddings import HuggingFaceEmbeddings\n",
+    "# Initialize HuggingFace Embeddings\n",
+    "embedding_model = HuggingFaceEmbeddings(model_name=\"sentence-transformers/all-MiniLM-L6-v2\")\n",
+    "\n",
+    "# Create FAISS Vector Store\n",
+    "vector_store = FAISS.from_texts(abstracts, embedding_model)\n",
+    "\n",
+    "# Perform a similarity search (RAG Retrieval Step)\n",
+    "query = \"best deep learning advancements\"\n",
+    "top_docs = vector_store.similarity_search(query, k=2)\n",
+    "\n",
+    "# Display Retrieved Documents\n",
+    "for i, doc in enumerate(top_docs):\n",
+    "    print(f\"Top {i+1} Result:\\n{doc.page_content}\\n\" + \"-\"*80)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Device set to use mps:0\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Agent: Time to flex my research muscles!\n",
+      "Top papers: ['First empirical study on 16,500 popular Android apps. Demystifies how smartphone apps exploit deep learning in the wild. Findings', 'The past, present and future of deep learning is presented in this work. We predict that deep cortical learning will be the convergence of deep']\n",
+      "Best pick: First empirical study on 16,500 popular Android apps. Demystifies how smartphone apps exploit deep learning in the wild. Findings\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Prerequisites: pip install langchain faiss-cpu transformers requests\n",
+    "import requests\n",
+    "from langchain.vectorstores import FAISS\n",
+    "from langchain.embeddings import HuggingFaceEmbeddings\n",
+    "from transformers import pipeline\n",
+    "\n",
+    "# Step 1: Define the Agent class (our Research Buddy)\n",
+    "class ResearchBuddyAgent:\n",
+    "    def __init__(self):\n",
+    "        # Load embeddings for RAG\n",
+    "        self.embeddings = HuggingFaceEmbeddings(model_name=\"all-MiniLM-L6-v2\")\n",
+    "        # Load summarizer (small model for speed)\n",
+    "        self.summarizer = pipeline(\"summarization\", model=\"facebook/bart-large-cnn\")\n",
+    "        self.papers = []  # Store fetched papers\n",
+    "\n",
+    "    # Step 2: Fetch papers (simple arXiv API call)\n",
+    "    def fetch_papers(self, topic):\n",
+    "        url = f\"http://export.arxiv.org/api/query?search_query=all:{topic}&start=0&max_results=5\"\n",
+    "        response = requests.get(url)\n",
+    "        # Parse the XML response\n",
+    "        root = ET.fromstring(response.text)\n",
+    "\n",
+    "        # Extract titles and abstracts\n",
+    "        abstracts = []  # List to store abstracts\n",
+    "        titles = []  # List to store titles\n",
+    "\n",
+    "        for entry in root.findall(\"{http://www.w3.org/2005/Atom}entry\"):\n",
+    "            title = entry.find(\"{http://www.w3.org/2005/Atom}title\").text.strip()\n",
+    "            abstract = entry.find(\"{http://www.w3.org/2005/Atom}summary\").text.strip()\n",
+    "\n",
+    "            titles.append(title)\n",
+    "            abstracts.append(abstract)\n",
+    "\n",
+    "    # Step 3: Build RAG vector store and retrieve\n",
+    "    def retrieve_relevant(self, query):\n",
+    "        # Create FAISS vector store from papers\n",
+    "        vector_store = FAISS.from_texts(abstracts, embedding_model)\n",
+    "        # Search for top matches\n",
+    "        top_docs = vector_store.similarity_search(query, k=2)\n",
+    "        return [doc.page_content for doc in top_docs]  # Extract text\n",
+    "\n",
+    "    # Step 4: Summarize papers\n",
+    "    def summarize_papers(self, papers):\n",
+    "        summaries = []\n",
+    "        for paper in papers:\n",
+    "            summary = self.summarizer(paper, max_length=30, min_length=15)[0][\"summary_text\"]\n",
+    "            summaries.append(summary)\n",
+    "        return summaries\n",
+    "\n",
+    "    # Step 5: Decide the \"best\" (simple rule: shortest summary wins)\n",
+    "    def pick_best(self, summaries):\n",
+    "        best = min(summaries, key=len)  # Lazy rule for demo\n",
+    "        return best\n",
+    "\n",
+    "    # Step 6: Main agent flow (plan and execute)\n",
+    "    def run(self, topic, query):\n",
+    "        print(\"Agent: Time to flex my research muscles!\")\n",
+    "        # Plan: Fetch → Retrieve → Summarize → Pick\n",
+    "        self.fetch_papers(topic)\n",
+    "        relevant_papers = self.retrieve_relevant(query)\n",
+    "        summaries = self.summarize_papers(relevant_papers)\n",
+    "        best_summary = self.pick_best(summaries)\n",
+    "        print(f\"Top papers: {summaries}\")\n",
+    "        print(f\"Best pick: {best_summary}\")\n",
+    "\n",
+    "# Run the agent\n",
+    "if __name__ == \"__main__\":\n",
+    "    agent = ResearchBuddyAgent()\n",
+    "    agent.run(topic=\"deep learning\", query=\"best deep learning advancements\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

hf_space/requirements.txt

@@ -6,5 +6,6 @@ transformers
 huggingface-hub
 loguru
 numpy
+sentence-transformers
 torch
-
+chromadb

requirements.txt

@@ -8,4 +8,4 @@ loguru
 numpy
 sentence-transformers
 torch
-
+chromadb