🤖 Tworzenie Inteligentnego Asystenta do zarządzania Urządzeniami Sieciowymi.

Czy kiedykolwiek marzyłeś o posiadaniu inteligentnego asystenta, który mógłby rozmawiać z urządzeniami sieciowymi, pomagać w konfiguracji oraz odpowiadać na pytania dotyczące statusu sieci? Dziś chętnie podzielę się z Wami rozszerzoną wersją mojego projektu Jak Stworzyć Asystenta AI, który Rozmawia ze Switchami Cisco? Pełny Tutorial.

Spis treści

• 🤖 Tworzenie Inteligentnego Asystenta do zarządzan …

  • Wstęp i Kontekst

  • Wymagania

    • Techniczne narzędzia i biblioteki:

    • Wymagania wstępne:

  • Sandbox i Cisco Nexus Switch Serii 9000

  • Opisanie działania kodu

    • Struktura katalogów

    • Dotenv (.env)

    • Frontend (frontend.py)

    • Backend (backend.py)

    • Działanie asystenta (talking_with_switches.py)

  • Uruchamianie i testowanie Aplikacji

    • Kroki do uruchomienia:

    • Testowanie aplikacji

  • Podsumowanie

  • Kod Źródłowy (tylko dla zalogowanych)

Wstęp i Kontekst

Budowa inteligentnego asystenta AI, który bezpośrednio komunikuje się z urządzeniami sieciowymi, to cel, którym chcę się z Wami podzielić. Taki asystent może znacznie usprawnić pracę sieciowców, automatyzując wiele rutynowych zadań, od zbierania informacji po konfigurowanie urządzeń. W tej wersji projektu z interfejsem użytkownika, zbudowanej za pomocą Streamlit oraz FastAPI na backendzie, rozszerzamy możliwości interakcji asystenta, łącząc go z OpenAI.

Projekt, o którym dziś opowiem, jest fascynujący, ponieważ pokazuje, jak połączyć sztuczną inteligencję z praktycznym zastosowaniem w zarządzaniu siecią.

Wymagania

Techniczne narzędzia i biblioteki:

Przykład z tego postu został stworzony i przetestowany na poniższych paczkach, które należy zainstalować.

pip install fastapi==0.111.0 load-dotenv==0.1.0 openai==1.26.0 python-dotenv==1.0.1 requests==2.32.2 streamlit==1.34.0

Wymagania wstępne:

• Podstawowa znajomość języka Python

• Zainstalowana biblioteka pip w środowisku Python

• Konto OpenAI z kluczem API

• dostęp do Cisco Sandbox (Cisco Nexus v9000)

Sandbox i Cisco Nexus Switch Serii 9000

Istotnym elementem w całej układance jest stabilne środowisko testowe, które pozwoli skupić się na meritum, czyli pisaniu kodu. Ponieważ opisywałem już, jak otrzymać dostęp do Cisco Nexus switcha całkowicie za darmo, to pozwolę sobie na przekierowanie Ciebie to mojego artykułu, w którym szczegółowo opisałem ten proces:

Opisanie działania kodu

Struktura katalogów

/
├── Frontend
│   └── frontend.py
├── Backend
│   └── backend.py
└── .env

Dotenv (.env)

Przykład pliku .env

OPENAI_API_KEY=sk-...

CISCO_USER=admin
CISCO_PASSWD=...

Frontend (frontend.py)

Kod frontendu odpowiada za interfejs użytkownika, który jest tworzony za pomocą Streamlit. Poniżej rozbijemy go na sekcje, aby lepiej zrozumieć jego działanie.

import streamlit as st
import requests

def get_response(user_query, chat_history):
    url = "http://localhost:8022/ask"
    data = {
        "question": user_query,
        "chat_history": str(chat_history)
        }
    headers = {"Content-Type": "application/json"}
    response = requests.post(url, json=data, headers=headers)
    if response.status_code == 200:
        decoded_message = response.json().get("reply")
        return decoded_message            
    else:
        return "Error: " + str(response.status_code)

1. import streamlit as st: Importuje bibliotekę Streamlit do tworzenia interfejsu użytkownika.

2. import requests: Importuje bibliotekę requests do wysyłania żądań HTTP.

Funkcja get_response wysyła zapytanie użytkownika i historię rozmowy do endpointu FastAPI (http://localhost:8022/ask), a następnie zwraca odpowiedź asystenta AI.

st.set_page_config(page_title="AI_Fresh Assistat")
st.title("🧑‍💻 AI Network Engineer")

Ustawienie tytułu strony i konfiguracja podstawowych ustawień aplikacji:

• st.set_page_config(page_title="AI_Fresh Assistat"): Ustawia tytuł strony wyświetlany na karcie przeglądarki.

• st.title("🧑‍💻 AI Network Engineer"): Wyświetla tytuł aplikacji na samej stronie.

if "chat_history" not in st.session_state:
    st.session_state.chat_history = []

print(st.session_state.chat_history)

Inicjalizacja historii czatu:

• Sprawdza, czy chat_history jest już zapisane w stanie sesji. Jeśli nie, inicjalizuje ją jako pustą listę.

for message in st.session_state.chat_history:
    if message.get("type") == "AI":
        with st.chat_message("AI"):
            st.write(message.get("content"))
    elif message.get("type") == "Human":
        with st.chat_message("Human"):
            st.write(message.get("content"))

Wyświetlanie historii rozmów:

• Iteruje przez historię czatu i wyświetla wiadomości w zależności od ich typu (AI lub człowiek).

user_query = st.chat_input("Type your message here...")
if user_query:
    st.session_state.chat_history.append(({"type": "Human", "content": user_query}))
    with st.chat_message("Human"):
        st.markdown(user_query)
    response = get_response(user_query, st.session_state.chat_history)
    with st.chat_message("AI"):
        print(response)
        st.write(response)
        st.session_state.chat_history.append(({"type": "AI", "content": response}))

Obsługa wejścia użytkownika:

• user_query = st.chat_input("Type your message here..."): Pole do wpisania wiadomości.

• if user_query: Po wpisaniu wiadomości przez użytkownika jest ona dodawana do historii czatu. Następnie wysyłane jest zapytanie do serwera, a odpowiedź AI jest wyświetlana i zapisywana w historii czatu.

Backend (backend.py)

Kod backendu zajmuje się przetwarzaniem zapytań użytkownika i udzielaniem odpowiedzi za pomocą modelu AI od OpenAI.

import os
from dotenv import load_dotenv
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from talking_with_switches import NetworkAssistant  # Adjust the import based on your file structure

load_dotenv()
app = FastAPI()

Inicjalizacja:

• Importowanie bibliotek.

• Ładowanie zmiennych środowiskowych z pliku .env (zawierającego m.in. klucz API do OpenAI).

• Inicjalizacja aplikacji FastAPI.

class QuestionRequest(BaseModel):
    question: str
    chat_history: str

class AnswerResponse(BaseModel):
    reply: str

Modele danych:

• QuestionRequest: Model danych dla zapytań użytkownika, który zawiera pytanie i historię czatu.

• AnswerResponse: Model danych odpowiedzi, który zawiera pole reply.

@app.post("/ask/", response_model=AnswerResponse)
async def ask(request: QuestionRequest):
    if not request.question:
        raise HTTPException(status_code=400, detail="Question content is empty")

    api_key = os.getenv("OPENAI_API_KEY")
    assistant = NetworkAssistant(api_key=api_key)
    print(request.chat_history)
    answer = assistant.make_decision(request.question, request.chat_history)
    print("answer: ", answer)

    if not answer:
        raise HTTPException(status_code=500, detail="Failed to get a response from the assistant")

    return AnswerResponse(reply=answer)

Endpoint /ask/:

• Obsługuje zapytania POST z pytaniem użytkownika i historią czatu.

• Inicjalizuje NetworkAssistant z kluczem API OpenAI.

• Wywołuje metodę make_decision w celu uzyskania odpowiedzi od asystenta AI.

• Zwraca odpowiedź asystenta lub rzuca odpowiedni wyjątek w przypadku błędu.

Działanie asystenta (talking_with_switches.py)

Kod w tym pliku zawiera klasę NetworkAssistant, która komunikuje się z OpenAI w celu uzyskania odpowiedzi oraz wywołuje odpowiednie funkcje do zarządzania urządzeniami sieciowymi.

import os
import json
import requests
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

Inicjalizacja:

• Importowanie niezbędnych bibliotek.

• Ładowanie zmiennych środowiskowych z pliku .env.

class NetworkAssistant:
    def __init__(self, api_key):
        self.client = OpenAI(api_key=api_key)

Konstruktor klasy NetworkAssistant:

• Inicjalizuje klienta OpenAI za pomocą klucza API.

def make_decision(self, user_input, chat_history):
        # ...
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo-16k",
            tools=tools,
            messages=[
                {"role": "system", "content": content},
                {"role": "user", "content": user_input},
            ],
        )

        ai_response = response.choices[0].message.content
        tool_calls = response.choices[0].message.tool_calls

        if tool_calls:
            # ...
            follow_up_response = self.function_run(user_input, **arguments)
            follow_up_content = follow_up_response.choices[0].message.content
            return follow_up_content
        else:
            return ai_response

• make_decision, która analizuje input użytkownika, odpowiednio się nim zajmuje używając modelu AI oraz wywołuje odpowiednie funkcje (jeśli wymaga tego kontekst).

Kod zawiera również funkcje (function_run, configure_devices oraz get_info_from_devices), które odpowiadają za łączenie się z urządzeniem sieciowym (w tym przykładzie z wirtualnym Cisco Nexus Switchem v9000) i albo wykonywaniem komend show lub komend konfiguracyjnych, w zależności od zapytań użytkownika.

Uruchamianie i testowanie Aplikacji

Kroki do uruchomienia:

1. Uruchomienie backendu:

uvicorn backend:app --reload

Upewnij się, że jesteś w terminalu, we właściwym folderze, w którym znajduje się backend.py

2. Uruchomienie frontendu:

streamlit run frontend.py

Upewnij się, że jesteś w terminalu, we właściwym folderze, w którym znajduje się frontend.py

Po uruchomieniu frontentu powinno otworzyć się okno w przeglądarce pokazujące GUI Asystenta.

Testowanie aplikacji

• Wprowadź przykładowe pytanie dotyczące sieci, takie jak: „Czy możesz zalogować się na switcha i sprawdzić, czy VLAN 13 jest skonfigurowany?”.

• Asystent prześle zapytanie do backendu, który następnie przekaże je do modelu AI. Zostanie wykonane odpowiednie zapytanie do urządzenia i odpowiedź zostanie wyświetlona.

Specjalnie napisałem do asystenta, prosząc go o sprawdzenie na switchu wersji NX-OSa oraz kiedy switch był ostatnio restartowany, nie podając mu nazwy switcha. Asystent nie dość, że sam zapytał o nazwę switcha, to i również sam wiedział co zrobić w momencie podania przeze mnie nazwy switcha. Wynik jest zadowalający i pokrywa się ze stanem rzeczywistym na switchu.

Asystent również świetnie sobie radzi z przeprowadzaniem konfiguracji. Pozwoliłem sobie zaprezentować jego możliwości, które przyznam szczerze, sprawiły, że miałem uśmiech od ucha, do ucha widząc te zaskakujące efekty, które przedstawiam poniżej.

Najpierw poprosiłem go o sprawdzenie i pokazanie mi konfiguracji interfejsu Eth1/1 na switchu, następnie poprosiłem o zmianę konfiguracji, mówiąc, jakie są moje wymagania. Asystent wykonał moją prośbę, potwierdzając wykonanie zadania.

Konfiguracja na switchu przed:

konfiguracja na switchu po:

Podsumowanie

W dzisiejszym poście omówiliśmy, jak stworzyć inteligentnego asystenta do rozmów z urządzeniami sieciowymi, korzystając z biblioteki Streamlit do interfejsu użytkownika oraz FastAPI do backendu. Uzyskaliśmy funkcjonalność, która pozwala sieciowcom na szybkie i skuteczne wykonywanie zadań, a przez to oszczędność czasu i zwiększenie wydajności.

Dalsze kroki, w których możecie się sprawdzić:

• Rozszerzenie funkcji asystenta o większą liczbę komend sieciowych.

• Integracja z dodatkowymi narzędziami monitorującymi.

Zachęcam do spróbowania własnych sił w budowie takiego asystenta i dostosowywania go do swoich potrzeb. Wasze pomysły i rozszerzenia mogą znacznie wpłynąć na przyszłość zarządzania siecią!

Kod Źródłowy (tylko dla zalogowanych)