AI Voice Assistant

1
sudo raspi-config

1
hostname -I

1
ssh pi@

1
sudo raspi-config

1
sudo apt update && sudo apt upgrade -y

1
sudo apt install python3 python3-pip -y

1
git clone https://github.com/abdel2000-dply/ODC-AI-Assistant.git
2
cd ODC-AI-Assistant
3
pip install -r requirements.txt

1
git clone https://github.com/waveshare/LCD-show.git
2
cd LCD-show/
3
sudo ./LCD35-show

1
sudo reboot

1
arecord -l

1
arecord -D plughw:1,0 -f cd test.wav
2
aplay test.wav

1
speaker-test -t wav -c 2

1
alsamixer

1
import cohere
2
import langchain
3
import whisper
4
import speech_recognition as sr
5
from edge_tts import Communicate
6
print("All libraries installed successfully!")

1
import speech_recognition as sr
2
recognizer = sr.Recognizer()
3
with sr.Microphone() as source:
4
    print("Say something...")
5
    audio = recognizer.listen(source)
6
    try:
7
        print("You said:", recognizer.recognize_google(audio))
8
    except sr.UnknownValueError:
9
        print("Could not understand the audio")

1
git clone https://github.com/abdel2000-dply/ODC-AI-Assistant.git

1
cd ODC-AI-Assistant
2
pip install -r requirements.txt

1
python3 main.py

1
import speech_recognition as sr
2

3
# Speech Recognition
4
# The project uses the speech_recognition library to capture voice input. Here’s the key code snippet:
5

6
def recognize_speech_from_mic(language='en-US', device_index=3):
7
  # Create a Recognizer instance to process speech
8
  recognizer = sr.Recognizer()
9

10
  # Use the specified microphone device for capturing audio
11
  # Ensure that the correct `device_index` is passed as an argument
12
  with sr.Microphone(device_index=device_index) as source:
13
    print("Please say something:")
14

15
    # Adjust for ambient noise to improve recognition accuracy
16
    recognizer.adjust_for_ambient_noise(source, duration=1)
17

18
    try:
19
      # Listen for speech input from the microphone with a timeout
20
      audio = recognizer.listen(source, timeout=10)
21

22
      # Convert the speech audio to text using Google Web Speech API
23
      text = recognizer.recognize_google(audio, language=language)
24
      print(f"You said: {text}")
25
      return text
26

27
    except sr.UnknownValueError:
28
      # Handle the case where the speech is unintelligible
29
      print("Unable to recognize speech")
30
      return None
31

32
    except Exception as e:
33
      # Handle other potential errors (e.g., device or network issues)
34
      print(f"An error occurred: {e}")
35
      return None
36

37
# Example usage (ensure the correct device_index for your microphone):
38
# recognize_speech_from_mic()

1
from selenium import webdriver
2
from selenium.webdriver.chrome.options import Options
3
from selenium.webdriver.common.by import By
4
import time # Importing time to allow for pauses (e.g., while waiting for elements to load)
5

6
# Function to scrape event data from the Orange Digital Center website
7
def scrape_events():
8
# Set up Chrome options for headless browsing
9
chrome_options = Options()
10
chrome_options.add_argument("--headless") # Ensures the browser runs in the background (no UI)
11
chrome_options.add_argument("--no-sandbox") # Disables sandboxing for security; often needed in server environments
12
chrome_options.add_argument("--disable-dev-shm-usage") # Prevents memory-related crashes in Docker containers
13
chrome_options.add_argument("--ignore-certificate-errors") # Ignores SSL certificate errors for seamless browsing
14

15
# Create a new instance of the Chrome WebDriver with the specified options
16
driver = webdriver.Chrome(options=chrome_options)
17

18
# Navigate to the Orange Digital Center events page
19
driver.get("https://www.orangedigitalcenters.com/country/ma/events")
20

21
# Wait for events to load completely
22
time.sleep(5) # This is a simple pause; consider using WebDriverWait for a more robust solution
23

24
# Extract event details from the loaded webpage
25
# Find all elements with the class name "event-detail"
26
events = driver.find_elements(By.CLASS_NAME, "event-detail")
27
for event in events: # Iterate through each event element
28
# Extract the event title
29
title = event.find_element(By.CLASS_NAME, "event-title").text
30
# Extract the event date
31
date = event.find_element(By.CLASS_NAME, "event-date").text
32
# Print the extracted details to the console
33
print(f"Event: {title}, Date: {date}")
34

35
# Close the browser once the extraction is complete
36
driver.quit()

1
from langchain.chains import ConversationalRetrievalChain # Import the ConversationalRetrievalChain class for handling conversation-based chains
2
from langchain.memory import ConversationBufferMemory # Import the ConversationBufferMemory class to store chat history
3
from langchain_cohere import ChatCohere # Import the ChatCohere class to integrate Cohere's language model
4

5
class LangChainHandler:
6
def __init__(self):
7
# Initialize the handler with Cohere's language model (replace "your_cohere_api_key" with actual API key)
8
self.llm = ChatCohere(api_key="your_cohere_api_key")
9

10
# Initialize the memory buffer to store the conversation history (key used to reference memory)
11
self.memory = ConversationBufferMemory(memory_key="chat_history")
12

13
# Set up the conversational chain, integrating the LLM (Cohere), memory, and retriever from the vector store
14
self.chain = ConversationalRetrievalChain.from_llm(
15
llm=self.llm, # Pass the Cohere language model
16
memory=self.memory, # Pass the memory buffer to track conversation context
17
retriever=vector_store.as_retriever() # Use the vector store retriever to fetch relevant information
18
)
19

20
def get_response(self, question):
21
# Process the user's question using the conversational chain and retrieve the response
22
response = self.chain({"question": question})
23

24
# Return the answer from the response object
25
return response["answer"]