Construct an clever multitool AI agent interface utilizing Streamlit for seamless real-time interplay

On this tutorial, we’ll construct one thing highly effective and interactive. Flow line An utility that brings collectively the capabilities of Langchain, Google Gemini APIs, and a set of superior instruments for creating good AI assistants. Use Streamlit’s intuitive interface to create a chat-based system that lets you search the online, retrieve Wikipedia content material, carry out calculations, bear in mind essential particulars, and deal with all of your dialog historical past in actual time. Whether or not you are exploring builders, researchers, or AI, this setup lets you work together with multi-agent programs immediately out of your browser with minimal code and most flexibility.

!pip set up -q streamlit langchain langchain-google-genai langchain-community
!pip set up -q pyngrok python-dotenv wikipedia duckduckgo-search
!npm set up -g localtunnel


import streamlit as st
import os
from langchain_google_genai import ChatGoogleGenerativeAI
from langchain.brokers import create_react_agent, AgentExecutor
from langchain.instruments import Instrument, WikipediaQueryRun, DuckDuckGoSearchRun
from langchain.reminiscence import ConversationBufferWindowMemory
from langchain.prompts import PromptTemplate
from langchain.callbacks.streamlit import StreamlitCallbackHandler
from langchain_community.utilities import WikipediaAPIWrapper, DuckDuckGoSearchAPIWrapper
import asyncio
import threading
import time
from datetime import datetime
import json

First, begin by putting in all of the required Python and node.js packages wanted on your AI Assistant app. This contains instruments corresponding to retrienlitt for the frontend, rung chain for agent logic, and Wikipedia, Duck Duckgo, ngrok/localtunnel for exterior search and internet hosting. As soon as arrange, import all of the modules and begin constructing an interactive multitool AI agent.

GOOGLE_API_KEY = "Use Your API Key Right here" 
NGROK_AUTH_TOKEN = "Use Your Auth Token Right here" 
os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY

Subsequent, configure the atmosphere by establishing the Google Gemini API key and ngrok authentication token. Assign these credentials to variables and set Google_Api_key to make sure that the Langchain agent has safe entry to the Gemini mannequin whereas it’s operating.

class InnovativeAgentTools:
   """Superior software assortment for the multi-agent system"""
  
   @staticmethod
   def get_calculator_tool():
       def calculate(expression: str) -> str:
           """Calculate mathematical expressions safely"""
           attempt:
               allowed_chars = set('0123456789+-*/.() ')
               if all(c in allowed_chars for c in expression):
                   end result = eval(expression)
                   return f"Outcome: {end result}"
               else:
                   return "Error: Invalid mathematical expression"
           besides Exception as e:
               return f"Calculation error: {str(e)}"
      
       return Instrument(
           identify="Calculator",
           func=calculate,
           description="Calculate mathematical expressions. Enter needs to be a sound math expression."
       )
  
   @staticmethod
   def get_memory_tool(memory_store):
       def save_memory(key_value: str) -> str:
           """Save info to reminiscence"""
           attempt:
               key, worth = key_value.break up(":", 1)
               memory_store[key.strip()] = worth.strip()
               return f"Saved '{key.strip()}' to reminiscence"
           besides:
               return "Error: Use format 'key: worth'"
      
       def recall_memory(key: str) -> str:
           """Recall info from reminiscence"""
           return memory_store.get(key.strip(), f"No reminiscence discovered for '{key}'")
      
       return [
           Tool(name="SaveMemory", func=save_memory,
                description="Save information to memory. Format: 'key: value'"),
           Tool(name="RecallMemory", func=recall_memory,
                description="Recall saved information. Input: key to recall")
       ]
  
   @staticmethod
   def get_datetime_tool():
       def get_current_datetime(format_type: str = "full") -> str:
           """Get present date and time"""
           now = datetime.now()
           if format_type == "date":
               return now.strftime("%Y-%m-%d")
           elif format_type == "time":
               return now.strftime("%H:%M:%S")
           else:
               return now.strftime("%Y-%m-%d %H:%M:%S")
      
       return Instrument(
           identify="DateTime",
           func=get_current_datetime,
           description="Get present date/time. Choices: 'date', 'time', or 'full'"
       )

Right here we outline the InnovativeAnttools class to equip AI brokers with particular options. Implement instruments corresponding to a calculator for protected illustration analysis, a reminiscence software that shops and recollects info all through the flip, and a date and time software that retrieves the present date and time. These instruments enable our streamlined AI brokers to motive, bear in mind and reply contextually, like true assistants. Please examine full Notes right here

class MultiAgentSystem:
   """Modern multi-agent system with specialised capabilities"""
  
   def __init__(self, api_key: str):
       self.llm = ChatGoogleGenerativeAI(
           mannequin="gemini-pro",
           google_api_key=api_key,
           temperature=0.7,
           convert_system_message_to_human=True
       )
       self.memory_store = {}
       self.conversation_memory = ConversationBufferWindowMemory(
           memory_key="chat_history",
           ok=10,
           return_messages=True
       )
       self.instruments = self._initialize_tools()
       self.agent = self._create_agent()
  
   def _initialize_tools(self):
       """Initialize all obtainable instruments"""
       instruments = []
      
       instruments.lengthen([
           DuckDuckGoSearchRun(api_wrapper=DuckDuckGoSearchAPIWrapper()),
           WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
       ])
      
       instruments.append(InnovativeAgentTools.get_calculator_tool())
       instruments.append(InnovativeAgentTools.get_datetime_tool())
       instruments.lengthen(InnovativeAgentTools.get_memory_tool(self.memory_store))
      
       return instruments
  
   def _create_agent(self):
       """Create the ReAct agent with superior immediate"""
       immediate = PromptTemplate.from_template("""
🤖 You're a sophisticated AI assistant with entry to a number of instruments and protracted reminiscence.


AVAILABLE TOOLS:
{instruments}


TOOL USAGE FORMAT:
- Suppose step-by-step about what you could do
- Use Motion: tool_name
- Use Motion Enter: your enter
- Watch for Statement
- Proceed till you've gotten a last reply


MEMORY CAPABILITIES:
- It can save you essential info utilizing SaveMemory
- You may recall earlier info utilizing RecallMemory
- At all times attempt to bear in mind consumer preferences and context


CONVERSATION HISTORY:
{chat_history}


CURRENT QUESTION: {enter}


REASONING PROCESS:
{agent_scratchpad}


Start your response together with your thought course of, then take motion if wanted.
""")
      
       agent = create_react_agent(self.llm, self.instruments, immediate)
       return AgentExecutor(
           agent=agent,
           instruments=self.instruments,
           reminiscence=self.conversation_memory,
           verbose=True,
           handle_parsing_errors=True,
           max_iterations=5
       )
  
   def chat(self, message: str, callback_handler=None):
       """Course of consumer message and return response"""
       attempt:
           if callback_handler:
               response = self.agent.invoke(
                   {"enter": message},
                   {"callbacks": [callback_handler]}
               )
           else:
               response = self.agent.invoke({"enter": message})
           return response["output"]
       besides Exception as e:
           return f"Error processing request: {str(e)}"

On this part, you’ll construct the MultiAgentsystem class, which is the core of your utility. Right here we use Langchain to combine Gemini Professional fashions and initialize all of the essential instruments, together with net search, reminiscence, calculator options. Configure React-style brokers with customized prompts that information software utilization and reminiscence dealing with. Lastly, outline a chat technique that enables brokers to course of consumer enter, invoke instruments when wanted, and generate clever, context-aware responses. Please examine full Notes right here

def create_streamlit_app():
   """Create the progressive Streamlit utility"""
  
   st.set_page_config(
       page_title="🚀 Superior LangChain Agent with Gemini",
       page_icon="🤖",
       format="extensive",
       initial_sidebar_state="expanded"
   )
  
   st.markdown("""
   <fashion>
   .main-header {
       background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
       padding: 1rem;
       border-radius: 10px;
       colour: white;
       text-align: middle;
       margin-bottom: 2rem;
   }
   .agent-response {
       background-color: #f0f2f6;
       padding: 1rem;
       border-radius: 10px;
       border-left: 4px strong #667eea;
       margin: 1rem 0;
   }
   .memory-card {
       background-color: #e8f4fd;
       padding: 1rem;
       border-radius: 8px;
       margin: 0.5rem 0;
   }
   </fashion>
   """, unsafe_allow_html=True)
  
   st.markdown("""
   <div class="main-header">
       <h1>🚀 Superior Multi-Agent System</h1>
       <p>Powered by LangChain + Gemini API + Streamlit</p>
   </div>
   """, unsafe_allow_html=True)
  
   with st.sidebar:
       st.header("🔧 Configuration")
      
       api_key = st.text_input(
           "🔑 Google AI API Key",
           kind="password",
           worth=GOOGLE_API_KEY if GOOGLE_API_KEY != "your-gemini-api-key-here" else "",
           assist="Get your API key from https://ai.google.dev/"
       )
      
       if not api_key:
           st.error("Please enter your Google AI API key to proceed")
           st.cease()
      
       st.success("✅ API Key configured")
      
       st.header("🤖 Agent Capabilities")
       st.markdown("""
       - 🔍 **Internet Search** (DuckDuckGo)
       - 📚 **Wikipedia Lookup**
       - 🧮 **Mathematical Calculator**
       - 🧠 **Persistent Reminiscence**
       - 📅 **Date & Time**
       - 💬 **Dialog Historical past**
       """)
      
       if 'agent_system' in st.session_state:
           st.header("🧠 Reminiscence Retailer")
           reminiscence = st.session_state.agent_system.memory_store
           if reminiscence:
               for key, worth in reminiscence.objects():
                   st.markdown(f"""
                   <div class="memory-card">
                       <sturdy>{key}:</sturdy> {worth}
                   </div>
                   """, unsafe_allow_html=True)
           else:
               st.information("No reminiscences saved but")
  
   if 'agent_system' not in st.session_state:
       with st.spinner("🔄 Initializing Superior Agent System..."):
           st.session_state.agent_system = MultiAgentSystem(api_key)
       st.success("✅ Agent System Prepared!")
  
   st.header("💬 Interactive Chat")
  
   if 'messages' not in st.session_state:
       st.session_state.messages = [{
           "role": "assistant",
           "content": """🤖 Hello! I'm your advanced AI assistant powered by Gemini. I can:


• Search the web and Wikipedia for information
• Perform mathematical calculations
• Remember important information across our conversation
• Provide current date and time
• Maintain conversation context


Try asking me something like:
- "Calculate 15 * 8 + 32"
- "Search for recent news about AI"
- "Remember that my favorite color is blue"
- "What's the current time?"
"""
       }]
  
   for message in st.session_state.messages:
       with st.chat_message(message["role"]):
           st.markdown(message["content"])
  
   if immediate := st.chat_input("Ask me something..."):
       st.session_state.messages.append({"function": "consumer", "content material": immediate})
       with st.chat_message("consumer"):
           st.markdown(immediate)
      
       with st.chat_message("assistant"):
           callback_handler = StreamlitCallbackHandler(st.container())
          
           with st.spinner("🤔 Considering..."):
               response = st.session_state.agent_system.chat(immediate, callback_handler)
          
           st.markdown(f"""
           <div class="agent-response">
               {response}
           </div>
           """, unsafe_allow_html=True)
          
           st.session_state.messages.append({"function": "assistant", "content material": response})
  
   st.header("💡 Instance Queries")
   col1, col2, col3 = st.columns(3)
  
   with col1:
       if st.button("🔍 Search Instance"):
           instance = "Seek for the newest developments in quantum computing"
           st.session_state.example_query = instance
  
   with col2:
       if st.button("🧮 Math Instance"):
           instance = "Calculate the compound curiosity on $1000 at 5% for 3 years"
           st.session_state.example_query = instance
  
   with col3:
       if st.button("🧠 Reminiscence Instance"):
           instance = "Keep in mind that I work as an information scientist at TechCorp"
           st.session_state.example_query = instance
  
   if 'example_query' in st.session_state:
       st.information(f"Instance question: {st.session_state.example_query}")

On this part, we’ll convey all of it collectively by constructing an interactive net interface utilizing Streamlit. Configure the app format, outline customized CSS types, and configure the sidebar to configure agent performance by getting into your API key. Initializes a multi-agent system, maintains message historical past, and permits a chat interface that enables customers to work together in actual time. For even simpler exploration, we additionally present pattern buttons for search, arithmetic and memory-related queries. Please examine full Notes right here

def setup_ngrok_auth(auth_token):
   """Setup ngrok authentication"""
   attempt:
       from pyngrok import ngrok, conf
      
       conf.get_default().auth_token = auth_token
      
       attempt:
           tunnels = ngrok.get_tunnels()
           print("✅ Ngrok authentication profitable!")
           return True
       besides Exception as e:
           print(f"❌ Ngrok authentication failed: {e}")
           return False
          
   besides ImportError:
       print("❌ pyngrok not put in. Putting in...")
       import subprocess
       subprocess.run(['pip', 'install', 'pyngrok'], examine=True)
       return setup_ngrok_auth(auth_token)


def get_ngrok_token_instructions():
   """Present directions for getting ngrok token"""
   return """
🔧 NGROK AUTHENTICATION SETUP:


1. Join an ngrok account:
  - Go to: https://dashboard.ngrok.com/signup
  - Create a free account


2. Get your authentication token:
  - Go to: https://dashboard.ngrok.com/get-started/your-authtoken
  - Copy your authtoken


3. Exchange 'your-ngrok-auth-token-here' within the code together with your precise token


4. Different strategies if ngrok fails:
  - Use Google Colab's built-in public URL function
  - Use localtunnel: !npx localtunnel --port 8501
  - Use serveo.web: !ssh -R 80:localhost:8501 serveo.web
"""

Right here we arrange a helper perform to authenticate NGROK. This lets you publish your native streamlined app to the web. Use the Pyngrok library to configure the authentication token and validate the connection. If the token is lacking or invalid, you may simply host and share apps from environments corresponding to Google Colab, as they supply detailed directions on how you can get it and counsel various tunnel strategies corresponding to LocalTunnel or Servo.

def major():
   """Most important perform to run the appliance"""
   attempt:
       create_streamlit_app()
   besides Exception as e:
       st.error(f"Software error: {str(e)}")
       st.information("Please examine your API key and take a look at refreshing the web page")

This Most important() perform acts as an entry level for streamlined functions. Simply name create_streamlit_app() and launch the complete interface. If one thing goes improper, corresponding to lacking API keys or failing to initialize the software, it gracefully catches the error, shows helpful messages, and understands how customers can get well and proceed the app easily.

def run_in_colab():
   """Run the appliance in Google Colab with correct ngrok setup"""
  
   print("🚀 Beginning Superior LangChain Agent Setup...")
  
   if NGROK_AUTH_TOKEN == "your-ngrok-auth-token-here":
       print("⚠️  NGROK_AUTH_TOKEN not configured!")
       print(get_ngrok_token_instructions())
      
       print("🔄 Trying various tunnel strategies...")
       try_alternative_tunnels()
       return
  
   print("📦 Putting in required packages...")
   import subprocess
  
   packages = [
       'streamlit',
       'langchain',
       'langchain-google-genai',
       'langchain-community',
       'wikipedia',
       'duckduckgo-search',
       'pyngrok'
   ]
  
   for package deal in packages:
       attempt:
           subprocess.run(['pip', 'install', package], examine=True, capture_output=True)
           print(f"✅ {package deal} put in")
       besides subprocess.CalledProcessError:
           print(f"⚠️  Failed to put in {package deal}")
  
   app_content=""'
import streamlit as st
import os
from langchain_google_genai import ChatGoogleGenerativeAI
from langchain.brokers import create_react_agent, AgentExecutor
from langchain.instruments import Instrument, WikipediaQueryRun, DuckDuckGoSearchRun
from langchain.reminiscence import ConversationBufferWindowMemory
from langchain.prompts import PromptTemplate
from langchain.callbacks.streamlit import StreamlitCallbackHandler
from langchain_community.utilities import WikipediaAPIWrapper, DuckDuckGoSearchAPIWrapper
from datetime import datetime


# Configuration - Exchange together with your precise keys
GOOGLE_API_KEY = "''' + GOOGLE_API_KEY + '''"
os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY


class InnovativeAgentTools:
   @staticmethod
   def get_calculator_tool():
       def calculate(expression: str) -> str:
           attempt:
               allowed_chars = set('0123456789+-*/.() ')
               if all(c in allowed_chars for c in expression):
                   end result = eval(expression)
                   return f"Outcome: {end result}"
               else:
                   return "Error: Invalid mathematical expression"
           besides Exception as e:
               return f"Calculation error: {str(e)}"
      
       return Instrument(identify="Calculator", func=calculate,
                  description="Calculate mathematical expressions. Enter needs to be a sound math expression.")
  
   @staticmethod
   def get_memory_tool(memory_store):
       def save_memory(key_value: str) -> str:
           attempt:
               key, worth = key_value.break up(":", 1)
               memory_store[key.strip()] = worth.strip()
               return f"Saved '{key.strip()}' to reminiscence"
           besides:
               return "Error: Use format 'key: worth'"
      
       def recall_memory(key: str) -> str:
           return memory_store.get(key.strip(), f"No reminiscence discovered for '{key}'")
      
       return [
           Tool(name="SaveMemory", func=save_memory, description="Save information to memory. Format: 'key: value'"),
           Tool(name="RecallMemory", func=recall_memory, description="Recall saved information. Input: key to recall")
       ]
  
   @staticmethod
   def get_datetime_tool():
       def get_current_datetime(format_type: str = "full") -> str:
           now = datetime.now()
           if format_type == "date":
               return now.strftime("%Y-%m-%d")
           elif format_type == "time":
               return now.strftime("%H:%M:%S")
           else:
               return now.strftime("%Y-%m-%d %H:%M:%S")
      
       return Instrument(identify="DateTime", func=get_current_datetime,
                  description="Get present date/time. Choices: 'date', 'time', or 'full'")


class MultiAgentSystem:
   def __init__(self, api_key: str):
       self.llm = ChatGoogleGenerativeAI(
           mannequin="gemini-pro",
           google_api_key=api_key,
           temperature=0.7,
           convert_system_message_to_human=True
       )
       self.memory_store = {}
       self.conversation_memory = ConversationBufferWindowMemory(
           memory_key="chat_history", ok=10, return_messages=True
       )
       self.instruments = self._initialize_tools()
       self.agent = self._create_agent()
  
   def _initialize_tools(self):
       instruments = []
       attempt:
           instruments.lengthen([
               DuckDuckGoSearchRun(api_wrapper=DuckDuckGoSearchAPIWrapper()),
               WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
           ])
       besides Exception as e:
           st.warning(f"Search instruments could have restricted performance: {e}")
      
       instruments.append(InnovativeAgentTools.get_calculator_tool())
       instruments.append(InnovativeAgentTools.get_datetime_tool())
       instruments.lengthen(InnovativeAgentTools.get_memory_tool(self.memory_store))
       return instruments
  
   def _create_agent(self):
       immediate = PromptTemplate.from_template("""
🤖 You're a sophisticated AI assistant with entry to a number of instruments and protracted reminiscence.


AVAILABLE TOOLS:
{instruments}


TOOL USAGE FORMAT:
- Suppose step-by-step about what you could do
- Use Motion: tool_name
- Use Motion Enter: your enter
- Watch for Statement
- Proceed till you've gotten a last reply


CONVERSATION HISTORY:
{chat_history}


CURRENT QUESTION: {enter}


REASONING PROCESS:
{agent_scratchpad}


Start your response together with your thought course of, then take motion if wanted.
""")
      
       agent = create_react_agent(self.llm, self.instruments, immediate)
       return AgentExecutor(agent=agent, instruments=self.instruments, reminiscence=self.conversation_memory,
                          verbose=True, handle_parsing_errors=True, max_iterations=5)
  
   def chat(self, message: str, callback_handler=None):
       attempt:
           if callback_handler:
               response = self.agent.invoke({"enter": message}, {"callbacks": [callback_handler]})
           else:
               response = self.agent.invoke({"enter": message})
           return response["output"]
       besides Exception as e:
           return f"Error processing request: {str(e)}"


# Streamlit App
st.set_page_config(page_title="🚀 Superior LangChain Agent", page_icon="🤖", format="extensive")


st.markdown("""
<fashion>
.main-header {
   background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
   padding: 1rem; border-radius: 10px; colour: white; text-align: middle; margin-bottom: 2rem;
}
.agent-response {
   background-color: #f0f2f6; padding: 1rem; border-radius: 10px;
   border-left: 4px strong #667eea; margin: 1rem 0;
}
.memory-card {
   background-color: #e8f4fd; padding: 1rem; border-radius: 8px; margin: 0.5rem 0;
}
</fashion>
""", unsafe_allow_html=True)


st.markdown('<div class="main-header"><h1>🚀 Superior Multi-Agent System</h1><p>Powered by LangChain + Gemini API</p></div>', unsafe_allow_html=True)


with st.sidebar:
   st.header("🔧 Configuration")
   api_key = st.text_input("🔑 Google AI API Key", kind="password", worth=GOOGLE_API_KEY)
  
   if not api_key:
       st.error("Please enter your Google AI API key")
       st.cease()
  
   st.success("✅ API Key configured")
  
   st.header("🤖 Agent Capabilities")
   st.markdown("- 🔍 Internet Searchn- 📚 Wikipedian- 🧮 Calculatorn- 🧠 Reminiscencen- 📅 Date/Time")
  
   if 'agent_system' in st.session_state and st.session_state.agent_system.memory_store:
       st.header("🧠 Reminiscence Retailer")
       for key, worth in st.session_state.agent_system.memory_store.objects():
           st.markdown(f'<div class="memory-card"><sturdy>{key}:</sturdy> {worth}</div>', unsafe_allow_html=True)


if 'agent_system' not in st.session_state:
   with st.spinner("🔄 Initializing Agent..."):
       st.session_state.agent_system = MultiAgentSystem(api_key)
   st.success("✅ Agent Prepared!")


if 'messages' not in st.session_state:
   st.session_state.messages = [{
       "role": "assistant",
       "content": "🤖 Hello! I'm your advanced AI assistant. I can search, calculate, remember information, and more! Try asking me to: calculate something, search for information, or remember a fact about you."
   }]


for message in st.session_state.messages:
   with st.chat_message(message["role"]):
       st.markdown(message["content"])


if immediate := st.chat_input("Ask me something..."):
   st.session_state.messages.append({"function": "consumer", "content material": immediate})
   with st.chat_message("consumer"):
       st.markdown(immediate)
  
   with st.chat_message("assistant"):
       callback_handler = StreamlitCallbackHandler(st.container())
       with st.spinner("🤔 Considering..."):
           response = st.session_state.agent_system.chat(immediate, callback_handler)
       st.markdown(f'<div class="agent-response">{response}</div>', unsafe_allow_html=True)
       st.session_state.messages.append({"function": "assistant", "content material": response})


# Instance buttons
st.header("💡 Attempt These Examples")
col1, col2, col3 = st.columns(3)
with col1:
   if st.button("🧮 Calculate 15 * 8 + 32"):
       st.rerun()
with col2:
   if st.button("🔍 Search AI information"):
       st.rerun()
with col3:
   if st.button("🧠 Bear in mind my identify is Alex"):
       st.rerun()
'''
  
   with open('streamlit_app.py', 'w') as f:
       f.write(app_content)
  
   print("✅ Streamlit app file created efficiently!")
  
   if setup_ngrok_auth(NGROK_AUTH_TOKEN):
       start_streamlit_with_ngrok()
   else:
       print("❌ Ngrok authentication failed. Attempting various strategies...")
       try_alternative_tunnels()

The run_in_colab() perform lets you simply deploy Streamlite apps immediately out of your Google Colab atmosphere. First, set up all the mandatory packages, then dynamically generate the whole retrylit app code and write it to the retrylit_app.py file. To allow public entry to your app from Colab, examine for the presence of a sound ngrok token. It additionally results in a fallback tunneling choice whether it is lacking or invalid. This setup lets you work together with AI brokers from anyplace inside a number of cells inside Colab. Please examine full Notes right here

def start_streamlit_with_ngrok():
   """Begin Streamlit with ngrok tunnel"""
   import subprocess
   import threading
   from pyngrok import ngrok
  
   def start_streamlit():
       subprocess.run(['streamlit', 'run', 'streamlit_app.py', '--server.port=8501', '--server.headless=true'])
  
   print("🚀 Beginning Streamlit server...")
   thread = threading.Thread(goal=start_streamlit)
   thread.daemon = True
   thread.begin()
  
   time.sleep(5)
  
   attempt:
       print("🌐 Creating ngrok tunnel...")
       public_url = ngrok.join(8501)
       print(f"🔗 SUCCESS! Entry your app at: {public_url}")
       print("✨ Your Superior LangChain Agent is now operating publicly!")
       print("📱 You may share this URL with others!")
      
       print("⏳ Preserving tunnel alive... Press Ctrl+C to cease")
       attempt:
           ngrok_process = ngrok.get_ngrok_process()
           ngrok_process.proc.wait()
       besides KeyboardInterrupt:
           print("👋 Shutting down...")
           ngrok.kill()
          
   besides Exception as e:
       print(f"❌ Ngrok tunnel failed: {e}")
       try_alternative_tunnels()


def try_alternative_tunnels():
   """Attempt various tunneling strategies"""
   print("🔄 Attempting various tunnel strategies...")
  
   import subprocess
   import threading
  
   def start_streamlit():
       subprocess.run(['streamlit', 'run', 'streamlit_app.py', '--server.port=8501', '--server.headless=true'])
  
   thread = threading.Thread(goal=start_streamlit)
   thread.daemon = True
   thread.begin()
  
   time.sleep(3)
  
   print("🌐 Streamlit is operating on http://localhost:8501")
   print("n📋 ALTERNATIVE TUNNEL OPTIONS:")
   print("1. localtunnel: Run this in a brand new cell:")
   print("   !npx localtunnel --port 8501")
   print("n2. serveo.web: Run this in a brand new cell:")
   print("   !ssh -R 80:localhost:8501 serveo.web")
   print("n3. Colab public URL (if obtainable):")
   print("   Use the 'Public URL' button in Colab's interface")
  
   attempt:
       whereas True:
           time.sleep(60)
   besides KeyboardInterrupt:
       print("👋 Shutting down...")


if __name__ == "__main__":
   attempt:
       get_ipython()
       print("🚀 Google Colab detected - beginning setup...")
       run_in_colab()
   besides NameError:
       major()

On this final half, you arrange the execution logic to run the app in your native atmosphere or inside Google Colab. The start_streamlit_with_nggrok() perform begins a retrylid server within the background, publishes it utilizing ngrok, making it simpler to entry and share. If ngrok fails, the try_alternative_tunnels() perform is lively with alternate tunnel choices corresponding to LocalTunnel or servo. The __main__ block routinely detects whether or not you are utilizing colab, launches the suitable setup, and makes your complete deployment course of clean, versatile and shareable from anyplace.

In conclusion, there’s a totally useful AI agent operating inside a complicated streamlined interface that may reply queries, remind customers of enter, and publish companies which can be printed utilizing Ngrok. We have seen how superior AI options might be built-in into engaging and user-friendly apps. From right here you may lengthen the agent’s instruments, plug in to bigger workflows, or deploy them as a part of an clever utility. With front-end and rung chain brokers powering the logic, Riremlid was used to construct a strong basis for the subsequent technology of interactive AI experiences.

Please examine full Notes right here. All credit for this examine might be directed to researchers on this undertaking. Additionally, please be at liberty to comply with us Twitter And do not forget to affix us 100k+ ml subreddit And subscribe Our Newsletter.

Asif Razzaq is CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, ASIF is dedicated to leveraging the chances of synthetic intelligence for social advantages. His newest efforts are the launch of MarkTechPost, a synthetic intelligence media platform. That is distinguished by its detailed protection of machine studying and deep studying information, and is straightforward to know by a technically sound and extensive viewers. The platform has over 2 million views every month, indicating its reputation amongst viewers.

Construct an clever multitool AI agent interface utilizing Streamlit for seamless real-time interplay

Arizona Senate revives Bitcoin Reserve Bitcoin Reserve Invoice

When will Amazon Prime Day finish?

Converter

Editors Pick

Newsletter

Categories

Related Posts

Leave a Comment Cancel Reply

Latest

Best selling

Top rated

Products

Latest Posts

Welcome to Ivugangingo!

Random Picks