Upload 5 files

app.py

@@ -0,0 +1,162 @@
+import os
+import json
+import sqlite3
+from datetime import datetime
+import streamlit as st
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_chroma import Chroma
+from langchain_groq import ChatGroq
+from langchain.memory import ConversationBufferMemory
+from langchain.chains import ConversationalRetrievalChain
+
+# Directory paths and configurations
+working_dir = os.path.dirname(os.path.abspath(__file__))
+config_data = json.load(open(f"{working_dir}/config.json"))
+GROQ_API_KEY = config_data["GROQ_API_KEY"]
+os.environ["GROQ_API_KEY"] = GROQ_API_KEY
+
+# Database setup
+def setup_db():
+    conn = sqlite3.connect("chat_history.db", check_same_thread=False)
+    cursor = conn.cursor()
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS chat_histories (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT,
+            timestamp TEXT,
+            day TEXT,
+            user_input TEXT,
+            assistant_response TEXT
+        )
+    """)
+    conn.commit()
+    return conn
+
+# Save chat history to SQLite
+def save_chat_history(conn, username, timestamp, day, user_input, assistant_response):
+    cursor = conn.cursor()
+    cursor.execute("""
+        INSERT INTO chat_histories (username, timestamp, day, user_input, assistant_response)
+        VALUES (?, ?, ?, ?, ?)
+    """, (username, timestamp, day, user_input, assistant_response))
+    conn.commit()
+
+# Vectorstore setup
+def setup_vectorstore():
+    embeddings = HuggingFaceEmbeddings()
+    vectorstore = Chroma(persist_directory="soil_vectordb", embedding_function=embeddings)
+    return vectorstore
+
+# Chatbot chain setup
+def chat_chain(vectorstore):
+    llm = ChatGroq(model="llama-3.1-70b-versatile", temperature=0)
+    retriever = vectorstore.as_retriever()
+    memory = ConversationBufferMemory(
+        llm=llm,
+        output_key="answer",
+        memory_key="chat_history",
+        return_messages=True
+    )
+    chain = ConversationalRetrievalChain.from_llm(
+        llm=llm,
+        retriever=retriever,
+        chain_type="stuff",
+        memory=memory,
+        verbose=True,
+        return_source_documents=True
+    )
+    return chain
+
+# Streamlit setup
+st.set_page_config(page_title="Soil.Ai", page_icon="🌱", layout="centered")
+st.title("🌱 Soil.Ai - Smart Farming Recommendations")
+st.subheader("AI-driven solutions for modern farming!")
+
+# Initialize database and session state
+if "conn" not in st.session_state:
+    st.session_state.conn = setup_db()
+
+if "username" not in st.session_state:
+    username = st.text_input("Enter your name to proceed:")
+    if username:
+        with st.spinner("Loading AI interface..."):
+            st.session_state.username = username
+            st.session_state.chat_history = []
+            st.session_state.vectorstore = setup_vectorstore()
+            st.session_state.conversational_chain = chat_chain(st.session_state.vectorstore)
+            st.success(f"Welcome, {username}! Start by choosing an option.")
+else:
+    username = st.session_state.username
+
+# Main interface
+if "conversational_chain" not in st.session_state:
+    st.session_state.vectorstore = setup_vectorstore()
+    st.session_state.conversational_chain = chat_chain(st.session_state.vectorstore)
+
+if "username" in st.session_state:
+    st.subheader(f"Hello {username}, choose your option below:")
+
+    # Option selection: Ask a general question or input sensor data
+    option = st.radio(
+        "Choose an action:",
+        ("Ask a general agriculture-related question", "Input sensor data for recommendations")
+    )
+
+    # Option 1: Ask AI any agriculture-related question
+    if option == "Ask a general agriculture-related question":
+        user_query = st.chat_input("Ask AI anything about agriculture...")
+        if user_query:
+            with st.spinner("Processing your query..."):
+                # Display user's query
+                with st.chat_message("user"):
+                    st.markdown(user_query)
+
+                # Get assistant's response
+                with st.chat_message("assistant"):
+                    response = st.session_state.conversational_chain({"question": user_query})
+                    assistant_response = response["answer"]
+                    st.markdown(assistant_response)
+
+                    # Save chat history
+                    st.session_state.chat_history.append({"role": "user", "content": user_query})
+                    st.session_state.chat_history.append({"role": "assistant", "content": assistant_response})
+
+                    # Save to database
+                    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                    day = datetime.now().strftime("%A")
+                    save_chat_history(st.session_state.conn, username, timestamp, day, user_query, assistant_response)
+
+    # Option 2: Input sensor data for recommendations
+    elif option == "Input sensor data for recommendations":
+        st.markdown("### Enter soil and environmental parameters:")
+        ph = st.number_input("Enter Soil pH", min_value=0.0, max_value=14.0, step=0.1)
+        moisture = st.number_input("Enter Soil Moisture (%)", min_value=0.0, max_value=100.0, step=0.1)
+        temperature = st.number_input("Enter Temperature (°C)", min_value=-50.0, max_value=60.0, step=0.1)
+        air_quality = st.number_input("Enter Air Quality Index (AQI)", min_value=0, max_value=500, step=1)
+
+        if st.button("Get Recommendations"):
+            if ph and moisture and temperature and air_quality:
+                with st.spinner("Analyzing data..."):
+                    # Prepare input query
+                    user_input = f"Recommendations for:\n- pH: {ph}\n- Moisture: {moisture}%\n- Temperature: {temperature}°C\n- Air Quality: {air_quality}"
+
+                    # Display user's input
+                    with st.chat_message("user"):
+                        st.markdown(user_input)
+
+                    # Get assistant's response
+                    with st.chat_message("assistant"):
+                        response = st.session_state.conversational_chain({"question": user_input})
+                        assistant_response = response["answer"]
+                        st.markdown(assistant_response)
+
+                        # Save chat history
+                        st.session_state.chat_history.append({"role": "user", "content": user_input})
+                        st.session_state.chat_history.append({"role": "assistant", "content": assistant_response})
+
+                        # Save to database
+                        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                        day = datetime.now().strftime("%A")
+                        save_chat_history(st.session_state.conn, username, timestamp, day, user_input, assistant_response)
+            else:
+                st.error("Please fill in all the fields!")

config.json

@@ -0,0 +1 @@
+{"GROQ_API_KEY": "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"}

requirements.txt

@@ -0,0 +1,12 @@
+streamlit==1.38.0
+langchain-community==0.2.16
+langchain-text-splitters==0.2.4
+langchain-chroma==0.1.3
+langchain-huggingface==0.0.3
+langchain-groq==0.1.9
+unstructured==0.15.0
+unstructured[pdf]==0.15.0
+nltk==3.8.1
+psycopg2-binary 
+pgvector
+langchain_postgres

vectorize_documents.py

@@ -0,0 +1,86 @@
+from langchain_community.document_loaders import UnstructuredFileLoader
+from langchain_community.document_loaders import DirectoryLoader
+from langchain_text_splitters import CharacterTextSplitter
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_chroma import Chroma
+
+
+# # Define a function to perform vectorization
+def vectorize_documents():
+    embeddings = HuggingFaceEmbeddings()
+
+    loader = DirectoryLoader(
+        path="Data",
+        glob="./*.pdf",
+        loader_cls=UnstructuredFileLoader
+    )
+
+    documents = loader.load()
+
+    # Splitting the text and creating chunks of these documents.
+    text_splitter = CharacterTextSplitter(
+        chunk_size=2000,
+        chunk_overlap=500
+    )
+
+    text_chunks = text_splitter.split_documents(documents)
+
+        # Store in Chroma vector DB
+    vectordb = Chroma.from_documents(
+        documents=text_chunks,
+        embedding=embeddings,
+        persist_directory="soil_vectordb"
+    )
+
+    print("Documents Vectorized and saved in VectorDB")
+
+
+
+# Expose embeddings if needed
+embeddings = HuggingFaceEmbeddings()
+
+
+# Main guard to prevent execution on import
+if __name__ == "__main__":
+    vectorize_documents()
+
+
+
+# # Define a function to perform vectorization
+# def vectorize_documents():
+#     # Loading the embedding model
+#     embeddings = HuggingFaceEmbeddings()
+
+#     loader = DirectoryLoader(
+#         path="Data",
+#         glob="./*.pdf",
+#         loader_cls=UnstructuredFileLoader
+#     )
+
+#     documents = loader.load()
+
+#     # Splitting the text and creating chunks of these documents.
+#     text_splitter = CharacterTextSplitter(
+#         chunk_size=2000,
+#         chunk_overlap=500
+#     )
+
+#     text_chunks = text_splitter.split_documents(documents)
+
+#     # Store in Chroma vector DB
+#     vectordb = Chroma.from_documents(
+#         documents=text_chunks,
+#         embedding=embeddings,
+#         persist_directory="vector_db_dir"
+#     )
+
+#     print("Documents Vectorized and saved in VectorDB")
+
+
+# # Expose embeddings if needed
+# embeddings = HuggingFaceEmbeddings()
+
+
+# # Main guard to prevent execution on import
+# if __name__ == "__main__":
+#     vectorize_documents()