In einem kürzlich erschienenen Hackathon habe ich Agri Bot entwickelt, einen KI-angetriebenen Chatbot, der Landwirten und landwirtschaftliche Enthusiasten unterstützen soll, indem er genaue und mehrsprachige landwirtschaftliche Informationen bereitstellt. Dieser Artikel führt Sie durch die Funktionen, die Architektur und den Code hinter Agri Bot und zeigt, wie er erweiterte Technologien nutzt, um ein benutzerfreundliches Erlebnis zu schaffen. Im Agrarsektor ist der Zugang zu rechtzeitigen und genauen Informationen für Landwirte und Landwirtschaftsbegeisterte von entscheidender Bedeutung. Eingeben Agri Boteine KI in Agriculture Chatbot, die die Informationslücke durch mehrsprachige Unterstützung und Echtzeitdaten überbringt.
Dies ist die Benutzeroberfläche der stromlitischen Agribot-App, sie ist ein mehrsprachiger, gesprächiger und Echtzeit-Bot:
Schlüsselmerkmale von Agri Bot: KI für Landwirte
Agri Bot ist mit mehreren herausragenden Funktionen ausgestattet, die es zu einer unschätzbaren KI für Landwirte machen:
- Mehrsprachige Unterstützung: Kommuniziert in mehreren Sprachen, einschließlich Englisch, Hindi, Telugu, Tamil, Bengali, Marathi und Punjabi.
- Gespräche mit AI-betrieben: Verwendet die LAMA 3-70B Modell intelligente und kontextbezogene Antworten liefern.
- Echtzeit-Informationsabruf: Integriert in Wikipedia, ArxivUnd Duckduckgo um die neuesten landwirtschaftlichen Daten zu holen.
- Kontextbewusstes Gedächtnis: Erinnert sich an frühere Interaktionen, um eine nahtlose Benutzererfahrung zu gewährleisten.
- Benutzerfreundliche Schnittstelle: Mit stromloser Erstellung erstellte Schnittstelle ist intuitiv und leicht zu navigieren.
Tech Stack für Agri Bot
Der Tech -Stack für Agri Bot beinhaltet:
- Frontend: Stromlit (python)
- Backend: Langchain, Openai LLM (über GROQ API)
- Suchwerkzeuge: Wikipedia, Arxiv, Duckduckgo
- Übersetzung: Google Übersetzer -API
- Speicherverwaltung: Langchain ConversationBuffermemory
Lesen Sie auch: Prime 7 Frameworks zum Bau von KI -Agenten im Jahr 2025
Schritte zum Aufbau des Agri -Bots
Hier ist eine Aufschlüsselung des Code, der Agri Bot versorgt:
1. Importieren von Bibliotheken
import os
import time
import streamlit as st
from langchain.reminiscence import ConversationBufferMemory
from langchain.brokers import initialize_agent, AgentType
from langchain.chat_models import ChatOpenAI
from langchain.schema import SystemMessage, HumanMessage, AIMessage
from langchain_community.instruments import WikipediaQueryRun, ArxivQueryRun, DuckDuckGoSearchRun
from langchain_community.utilities import WikipediaAPIWrapper, ArxivAPIWrapper, DuckDuckGoSearchAPIWrapper
from langdetect import detect
from deep_translator import GoogleTranslator
from dotenv import load_dotenv, find_dotenvWir beginnen damit, die notwendigen Bibliotheken zu importieren. Streamlit wird für die Webschnittstelle verwendet, während Langchain Instruments zum Aufbau von Konversationsmitteln bietet. Die Deep_translator -Bibliothek wird für die Sprachübersetzung verwendet.
2. Variablen für Ladeumgebung
load_dotenv(find_dotenv())Diese Zeile lädt Umgebungsvariablen aus einer .env -Datei, die vertrauliche Informationen wie API -Schlüssel enthält.
3. Initialisieren von KI -Werkzeugen
wiki = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=200))
arxiv = ArxivQueryRun(api_wrapper=ArxivAPIWrapper(top_k_results=1, doc_content_chars_max=200))
duckduckgo_search = DuckDuckGoSearchRun(api_wrapper=DuckDuckGoSearchAPIWrapper(area="in-en", time="y", max_results=2))
instruments = (wiki, arxiv, duckduckgo_search)Hier initialisieren wir die Instruments zum Abrufen von Informationen von Wikipedia, Arxiv und Duckduckgo. Jedes Instrument ist so konfiguriert, dass eine begrenzte Anzahl von Ergebnissen zurückgegeben wird, um schnelle Antworten zu gewährleisten.
4. Laden des Sprachmodells
def load_llm():
return ChatOpenAI(
model_name="llama3-70b-8192",
temperature=1,
openai_api_key=os.getenv("GROQ_API_KEY"),
openai_api_base="https://api.groq.com/openai/v1"
)Diese Funktion lädt das Sprachmodell mit der GROQ -API. Der Temperaturparameter steuert die Zufälligkeit der Antworten des Modells.
5. Übersetzungsfunktionen
def translate_to_english(textual content):
attempt:
detected_lang = detect(textual content) # Detect language
if detected_lang == "en":
return textual content, "en" # No translation wanted
translated_text = GoogleTranslator(supply=detected_lang, goal="en").translate(textual content)
return translated_text, detected_lang # Return translated textual content and authentic language
besides Exception as e:
return textual content, "unknown" # Return authentic textual content if translation fails
def translate_back(textual content, target_lang):
attempt:
if target_lang == "en":
return textual content # No translation wanted
return GoogleTranslator(supply="en", goal=target_lang).translate(textual content)
besides Exception as e:
return textual content # Return authentic if translation failsDiese Funktionen verarbeiten die Übersetzung der Benutzereingabe in Englisch und zurück in die Originalsprache. Sie verwenden die Deep_translator -Bibliothek, um die Übersetzungen durchzuführen.
6. Speicherverwaltung
if "chat_memory" not in st.session_state:
st.session_state.chat_memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)Dieser Code stellt sicher, dass der Chat -Speicher über Sitzungen hinweg anhaltend ist und dem Bot sich an frühere Interaktionen erinnern kann.
7. Erstellen des Konversationsagenten
def get_conversational_agent():
llm = load_llm()
return initialize_agent(
instruments=instruments,
llm=llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
reminiscence=st.session_state.chat_memory,
verbose=True,
return_intermediate_steps=False,
max_iterations=5,
handle_parsing_errors=True
)Diese Funktion initialisiert den Konversationsagenten mit dem geladenen Sprachmodell und den Instruments zum Abrufen von Informationen.
8. Streamlit Chat UI
def essential():
# Set Background Picture
...
st.title("🌾 Agri Bot (Multilingual) 🌾")
st.subheader("Your Good Assistant for Farming and Agriculture")
if st.button("Reset Dialog"):
st.session_state.chat_memory.clear()
st.session_state.messages = ()
st.success("Chat historical past cleared!")
if "messages" not in st.session_state:
st.session_state.messages = ()
# Show previous chat historical past
for message in st.session_state.messages:
st.chat_message(message("function")).markdown(message("content material"))
# Get consumer enter
immediate = st.chat_input("Ask your farming-related query right here (in any language)...")
if immediate:
st.chat_message("consumer").markdown(immediate)
st.session_state.messages.append({"function": "consumer", "content material": immediate})
attempt:
translated_query, original_lang = translate_to_english(immediate)
st.write(f"🔍 *Detected Language:* {original_lang.higher()}") # Present detected language
st.write(f"🔄 *Translated Question:* {translated_query}") # Present translated question
agent = get_conversational_agent()
def trim_chat_memory(max_length=5):#
""" Retains solely the final `max_length` messages in reminiscence. """
chat_history = st.session_state.chat_memory.load_memory_variables({})("chat_history")
if len(chat_history) > max_length:
st.session_state.chat_memory.chat_memory.messages = chat_history(-max_length:)#
return chat_history
# Apply trimming earlier than invoking the agent
chat_history = trim_chat_memory(max_length=5)#
conversation_context = "n".be part of((msg.content material for msg in chat_history))
full_prompt = f"""
Earlier dialog:
{conversation_context}
Consumer: {immediate}
Assistant: Think twice. You might be allowed to look a most of two instances strictly.
You probably have discovered sufficient info from earlier searches, STOP looking out and generate an convincing reply utilizing the accessible information.
"""
# Retry in case of rate-limit errors
max_retries = 3
for try in vary(max_retries):
attempt:
response = agent.invoke({"enter": full_prompt})
break # Exit loop if profitable
besides Exception as e:
st.warning(f"⚠ API Fee Restrict! Retrying {try + 1}/{max_retries}...")
time.sleep(2) # Wait and retry
response_text = response("output") if isinstance(response, dict) and "output" in response else str(response)
final_response = translate_back(response_text, original_lang) # Translate again to authentic language
st.chat_message("assistant").markdown(final_response)
st.session_state.messages.append({"function": "assistant", "content material": final_response})
besides Exception as e:
st.error(f"Error: {str(e)}")Code Erläuterung
Lassen Sie uns Schritt für Schritt die Funktionalität des Codes aufschlüsseln:
1. Streamlit Setup
Der Code initialisiert eine Streamlit -Anwendung und erstellt die Benutzeroberfläche für den Chatbot.
2. CHAT -Eingabe
St.Chat_Input erstellt einen Texteingabebereich, in dem der Benutzer seine Nachrichten eingeben kann.
3.. Benutzernachrichtsverarbeitung
Wenn der Benutzer eine Nachricht einreicht:
- Die Nachricht wird erfasst.
- Translate_to_English konvertiert die Nachricht des Benutzers in Englisch. Dies ist entscheidend für die konsistente Interaktion mit dem englisch-zentrierten LLM.
- Die ursprünglichen (Benutzersprache) und übersetzten (englischen) Nachrichten werden im Chat -Fenster mit St.Chat_Message angezeigt.
4. Langchain -Agent -Abfrage
- get_conversational_agent wird aufgerufen, um einen Langchain -Agenten abzurufen oder zu initialisieren. Dieser Agent ist für Konversationsfragen ausgelegt, wobei wahrscheinlich ein LLM und möglicherweise andere Instruments verwendet werden.
- Der aktuelle Gesprächsgeschichte (von St.Session_State.chat_Memory) ist in der Eingabeaufforderung enthalten, die an den Agenten gesendet wurde. Dieser Kontext ist für ein kohärentes Gespräch unerlässlich.
- Der Agent verarbeitet die Eingabeaufforderung (einschließlich der übersetzten Nachricht des Benutzers und des Chat -Verlaufs) und generiert eine Antwort auf Englisch.
5. Reaktionsbehandlung
- Die englische Antwort des Agenten wird gespeichert.
- Translate_back konvertiert die englische Antwort des Agenten in die ursprüngliche Sprache des Benutzers.
- Die übersetzte Antwort wird im Chat -Fenster mit St.Chat_Message angezeigt.
6. Kontextmanagement
trim_chat_memory wird aufgerufen, um die in St.Session_State.chat_Memory gespeicherte Konversationsgeschichte einzuschränken. Dies verhindert, dass der Kontext für die LLM zu groß wird, was eine häufige Einschränkung darstellt. Normalerweise hält es nur die neuesten Nachrichten.
7. Mechanismus wiederholen
Der Code enthält eine Wiederholungsschleife. Wenn der API -Aufruf an den LLM- oder Übersetzungsdienst fehlschlägt (z. B. aufgrund von Zinsbegrenzung oder vorübergehenden Netzwerkproblemen), wird der Code die Anforderung eine bestimmte Anzahl von Malen wiederholen, bevor er aufgibt. Dies macht den Chatbot robuster.
8. Fehlerbehandlung
Der Code enthält Versuch… mit Ausnahme von Blöcken, um potenzielle Fehler bei API -Aufrufen oder anderen Vorgängen zu fangen. Dies verhindert, dass die Anwendung abstürzt, und bietet ein benutzerfreundlicheres Erlebnis (z. B. eine Fehlermeldung).
9. Sitzungsstatus
St.Session_State wird verwendet, um Daten zu speichern, die über Benutzerinteraktionen hinweg bestehen. Insbesondere speichert es das Chat_Memory, das die Geschichte des Gesprächs ist. Auf diese Weise kann der Chatbot den Kontext über mehrere Kurven aufrechterhalten. Ohne St.Session_State würde das Gespräch mit jeder neuen Nachricht frisch beginnen.
Testen des Agribots: eine KI für Landwirte
Dies ist die Benutzeroberfläche der streamlitischen App.
Hier fragte ich den Bot: „Was sind die Pflanzen in Haryana?“
Jetzt gibt es Echtzeit-Antworten mithilfe von Websuche, Wikipedia und Arxiv AI-Agenten und präsentiert genau Antworten.
Dieses Bild zeigt, dass Agribot verschiedene regionale Sprachen verstehen und in diesen Sprachen antworten kann. Hier können wir sehen, dass die erkannte Sprache tamilisch „te“ ist und die Ausgabe auch in tamilischer Sprache ist.
Zukünftige Verbesserungen der KI für Landwirte
Während Agri Bot funktional ist, gibt es mehrere Verbesserungsbereiche:
- Spracheingabe und Antworten: Das Hinzufügen von Unterstützung für Sprachinteraktionen kann die Zugänglichkeit verbessern.
- Domänenspezifische Feinabstimmung: Die Feinabstimmung des Modells zu landwirtschaftlichen Daten könnte die Reaktionsgenauigkeit verbessern.
- UI/UX -Verbesserungen: Weitere Verbesserungen der Benutzeroberfläche könnten eine bessere Benutzererfahrung bieten.
Abschluss
Agri Bot ist ein leistungsstarkes Werkzeug, das KI und mehrsprachige Fähigkeiten nutzt, um Landwirten und landwirtschaftliche Enthusiasten zu unterstützen. Die Kombination aus Echtzeitinformationen Abruf, Sprachübersetzung und Konversationsgedächtnis macht es zu einer einzigartigen und wertvollen Ressource. Ich freue mich darauf, dieses Projekt weiter zu entwickeln und neue Funktionen zu erforschen, um seine Funktionalität der KI in der Landwirtschaft zu verbessern.
Harsh Mishra ist ein KI/ML -Ingenieur, der mehr Zeit damit verbringt, mit großen Sprachmodellen zu sprechen als mit tatsächlichen Menschen. Leidenschaft über Genai, NLP und Maschinen schlauer (damit sie ihn noch nicht ersetzen). Wenn er Fashions nicht optimiert, optimiert er wahrscheinlich seine Kaffeeaufnahme. 🚀☕