7 files uploaded

.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$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/
+
+# 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
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# 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
+.envrc
+.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/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

README.md

@@ -1,14 +1,143 @@
----
-title: AgriEdge
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.0.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: A smart farm assistant
----
-
-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).
+# 🌾 AgriEdge: Smart Farm Assistant
+
+An AI-powered assistant that uses real-time sensor data and textbook-based agricultural knowledge to provide insights, analysis, and actionable suggestions for small to medium-scale farms. Comes with both command-line and web interfaces.
+
+---
+
+## 🚀 Features
+
+- 📡 Analyzes **real-time farm sensor data** (soil, water, environment)
+- 📚 Retrieves context from **agricultural PDF documents**
+- 🤖 Uses **retrieval-augmented generation (RAG)** for grounded reasoning
+- 🧠 Powered by **Ollama + LLaMA 3**
+- 📝 Generates **natural language summaries and actionable insights**
+- 🔒 Runs **fully local** — no cloud, no data sharing
+- 🌐 Supports **Streamlit-based dashboard** for non-technical users
+
+---
+
+## 📁 Project Structure
+
+```bash
+smartfarm/
+├── main.py                       # Command-line interface
+├── app.py                        # Streamlit web app
+├── llm/
+│   ├── ollama_llm.py             # Query handler using LLM + sensor data + RAG
+│   └── rag_pipeline.py           # PDF retrieval pipeline using FAISS
+├── logger.py                     # Logging setup
+├── prompt.txt                    # Prompt template for LLM
+├── data/
+│   ├── farm_data_log.json        # JSON file logging sensor readings
+│   ├── docs/                     # Agricultural PDFs for knowledge retrieval
+│   └── faiss_index/              # Auto-generated FAISS vector index
+```
+
+---
+
+## 🛠️ Installation & Setup
+
+### 1. Clone the Repository
+
+```bash
+git clone https://github.com/your-username/smartfarm.git
+cd smartfarm
+```
+
+### 2. Install Python Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 3. Set Up Ollama
+
+Make sure you have Ollama installed and running.
+
+Download the LLaMA 3 model:
+
+```bash
+ollama run llama3
+```
+
+Make sure Ollama is running in the background before using the assistant.
+
+### 4. Add Sensor Data
+
+Append new entries to `data/farm_data_log.json`. Example format:
+
+```json
+{
+  "timestamp": "2025-07-22T21:00:00+01:00",
+  "soil": {"moisture": "High", "pH": 6.8, "temperature": 24.9},
+  "water": {"pH": 7.2, "turbidity": "8 NTU", "temperature": 23.3},
+  "environment": {"humidity": "85%", "temperature": 26.0, "rainfall": "Moderate"}
+}
+```
+
+### 5. Add Agricultural Documents (Optional)
+
+Place your farming-related PDFs inside:
+
+```bash
+data/docs/
+```
+
+The system will automatically build a searchable vector index.
+
+---
+
+## ▶️ Usage
+
+### 📟 Command-Line Mode
+
+```bash
+python main.py
+```
+
+You’ll be prompted to enter queries like:
+
+```markdown
+> Is the soil suitable for planting now?
+> Has the turbidity improved compared to earlier?
+```
+
+Type `exit` to quit.
+
+### 🌐 Streamlit Web Interface
+
+Launch the UI with:
+
+```bash
+streamlit run app.py
+```
+
+What you can do:
+
+- View the most recent sensor snapshot
+- Ask farm-related questions like:
+  - "What is the current soil condition?"
+  - "Is it safe to irrigate now?"
+  - "Has rainfall increased compared to earlier?"
+
+---
+
+## 💡 Notes
+
+- The system analyzes only the most recent sensor reading but uses the previous 2 for historical comparison (internally).
+- No internet connection is required once the vector store and model are set up.
+- Logs are written automatically to `logs/`.
+
+---
+
+## 🧪 Example Questions
+
+- "Is the soil moisture improving?"
+- "What is the overall environmental condition right now?"
+- "Is the water quality good for irrigation?"
+
+---
+
+## 📄 License
+
+MIT License

app.py

@@ -1,64 +1,115 @@
-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()
+import gradio as gr
+import json
+from llm.ollama_llm import query_ollama
+from llm.rag_pipeline import retrieve_context
+from logger import get_logger
+
+logger = get_logger(__name__)
+
+# Function to load latest sensor data
+def get_latest_sensor_data(path="data/farm_data_log.json", num_entries=3):
+    try:
+        with open(path, "r") as f:
+            data = json.load(f)
+            return data[-num_entries:] if data else []
+    except FileNotFoundError:
+        logger.error(f"Sensor data file {path} not found.")
+        return []
+    except json.JSONDecodeError as e:
+        logger.error(f"Invalid JSON in {path}: {e}")
+        return []
+
+# Global query history
+query_history = []
+
+def process_query(user_query):
+    """Handles user query and returns response + updated history."""
+    if not user_query.strip():
+        return "Please enter a question.", "\n".join(format_history())
+
+    logger.info("User query: %s", user_query)
+    try:
+        # Prepare sensor data
+        sensor_data_entries = get_latest_sensor_data()
+        combined_sensor_data = {
+            entry["timestamp"]: {
+                "soil": entry["soil"],
+                "water": entry["water"],
+                "environment": entry["environment"]
+            }
+            for entry in sensor_data_entries
+        }
+        # Retrieve context and query LLM
+        rag_context = retrieve_context(user_query)
+        response = query_ollama(user_query, combined_sensor_data, rag_context)
+        logger.info("--- FARM ASSISTANT RESPONSE ---")
+
+        # Add to query history
+        query_history.append((user_query, response))
+
+        return response, format_history()
+    except Exception as e:
+        logger.error(f"Query processing failed: {e}")
+        return "Error: Could not process query. Please try again.", "\n".join(format_history())
+
+def format_history():
+    """Format query history as text for display."""
+    lines = []
+    for i, (q, r) in enumerate(query_history[-5:], start=1):
+        lines.append(f"### Query {i}\n**Q:** {q}\n**A:** {r}\n")
+    return "\n\n".join(lines)
+
+def clear_history():
+    query_history.clear()
+    return "", ""  # Clears both output panels
+
+# Show latest sensor data as markdown
+def display_sensor_data():
+    sensor_data_entries = get_latest_sensor_data()
+    if not sensor_data_entries:
+        return "No sensor data available."
+
+    latest_entry = sensor_data_entries[-1]
+    text = f"""
+**Latest Reading: {latest_entry['timestamp']}**
+
+### Soil
+- Moisture: {latest_entry['soil']['moisture']}
+- pH: {latest_entry['soil']['pH']}
+- Temperature: {latest_entry['soil']['temperature']}
+
+### Water
+- pH: {latest_entry['water']['pH']}
+- Turbidity: {latest_entry['water']['turbidity']}
+- Temperature: {latest_entry['water']['temperature']}
+
+### Environment
+- Humidity: {latest_entry['environment']['humidity']}
+- Temperature: {latest_entry['environment']['temperature']}
+- Rainfall: {latest_entry['environment']['rainfall']}
+"""
+    return text
+
+# Gradio UI
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="green")) as demo:
+    gr.Markdown("# 🌾 AgriEdge: Smart Farm Assistant")
+    gr.Markdown("Ask about your farm's conditions and get tailored advice based on sensor data.")
+
+    with gr.Tab("Ask Assistant"):
+        query = gr.Textbox(
+            label="Enter your farm-related question",
+            placeholder="e.g., What should I do about soil moisture?"
+        )
+        submit_btn = gr.Button("Submit Query")
+        clear_btn = gr.Button("Clear History")
+
+        response_box = gr.Markdown()
+        history_box = gr.Markdown()
+
+        submit_btn.click(process_query, inputs=query, outputs=[response_box, history_box])
+        clear_btn.click(clear_history, inputs=None, outputs=[response_box, history_box])
+
+    with gr.Tab("Recent Sensor Data"):
+        sensor_md = gr.Markdown(display_sensor_data())
+
+demo.launch()

logger.py

@@ -0,0 +1,20 @@
+# logger.py
+import logging
+
+def get_logger(name: str):
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+
+    # Console handler
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.INFO)
+
+    # Formatter
+    formatter = logging.Formatter('[%(levelname)s] %(asctime)s - %(name)s: %(message)s', "%H:%M:%S")
+    ch.setFormatter(formatter)
+
+    # Avoid duplicate logs
+    if not logger.handlers:
+        logger.addHandler(ch)
+
+    return logger

main.py

@@ -0,0 +1,48 @@
+import json
+from llm.ollama_llm import query_ollama
+from llm.rag_pipeline import retrieve_context
+from logger import get_logger
+
+logger = get_logger(__name__)
+
+def get_latest_sensor_data(path="data/farm_data_log.json", num_entries=3):
+    try:
+        with open(path, "r") as f:
+            data = json.load(f)
+            return data[-num_entries:] if data else []
+    except FileNotFoundError:
+        logger.error(f"Sensor data file {path} not found.")
+        return []
+    except json.JSONDecodeError as e:
+        logger.error(f"Invalid JSON in {path}: {e}")
+        return []
+
+def main():
+    logger.info("Smart Farm Assistant started.")
+    while True:
+        user_query = input("> ")
+        if user_query.lower() == 'exit':
+            logger.info("Exiting Smart Farm Assistant.")
+            break
+        logger.info("User query: %s", user_query)
+        logger.info("Retrieving latest sensor data...")
+        sensor_data_entries = get_latest_sensor_data()
+        combined_sensor_data = {
+            entry["timestamp"]: {
+                "soil": entry["soil"],
+                "water": entry["water"],
+                "environment": entry["environment"]
+            }
+            for entry in sensor_data_entries
+        }
+        try:
+            rag_context = retrieve_context(user_query)
+            response = query_ollama(user_query, combined_sensor_data, rag_context)
+            logger.info("\n--- FARM ASSISTANT RESPONSE ---\n")
+            print(response)
+        except Exception as e:
+            logger.error(f"Query processing failed: {e}")
+            print("Error: Could not process query. Please try again.")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1 +1,6 @@
-huggingface_hub==0.25.2
+numpy
+faiss-cpu
+tqdm
+PyPDF2
+streamlit
+requests

template.py

@@ -0,0 +1,40 @@
+import os
+
+# Define directory structure
+project_structure = {
+    "sensors": [
+        "sensor_collector.py"
+    ],
+    "llm": [
+        "ollama_llm.py",
+        "rag_pipeline.py"
+    ],
+    "data": [
+        "farm_data_log.json",
+        "docs/",           # Folder
+        "faiss_index/"     # Folder
+    ],
+    ".": [                # Root directory
+        "main.py",
+        "requirements.txt"
+    ]
+}
+
+def create_structure(base_path="."):
+    for folder, items in project_structure.items():
+        folder_path = os.path.join(base_path, folder) if folder != "." else base_path
+        os.makedirs(folder_path, exist_ok=True)
+
+        for item in items:
+            item_path = os.path.join(folder_path, item)
+            if item.endswith("/"):
+                os.makedirs(item_path, exist_ok=True)
+                print(f"Created folder: {item_path}")
+            else:
+                if not os.path.exists(item_path):
+                    with open(item_path, "w") as f:
+                        pass
+                print(f"Created file: {item_path}")
+
+if __name__ == "__main__":
+    create_structure()