Skip to content
The Chat Archive
gemini-2.5-pro· Google LMArena Human Preference 140K

Vytvoření AI agenta se znalostí konkrétního systému na základě HTML Web Helpu. Web Help…

  1. User

    Vytvoření AI agenta se znalostí konkrétního systému na základě HTML Web Helpu. Web Help je v HTML formátu (mam ulozene slozky s obrazky a se vsim v pocitaci v korenove slozce) a budu potřebovat způsob, jak z něj extrahovat textový obsah a připravit ho pro trénování nebo dotazování AI modelu.

  2. Assistant

    Skvělý dotaz! Vytvoření takového AI agenta je dnes velmi častý a řešitelný úkol. Proces si rozdělíme do několika logických kroků. Ukážu vám principy, konkrétní nástroje a poskytnu i vzorový kód v Pythonu, který je pro tento účel nejvhodnější.

    Celý proces se skládá ze tří hlavních fází:

    1. Extrakce a čištění dat: Získání čistého textu z HTML souborů.
    2. Příprava dat pro AI (Indexace): Strukturování textu a vytvoření "znalostní báze", ve které může AI rychle vyhledávat.
    3. Vytvoření dotazovacího rozhraní (Agent): Propojení znalostní báze s jazykovým modelem (LLM), který bude odpovídat na dotazy.

    Pojďme se na jednotlivé fáze podívat detailně.


    Fáze 1: Extrakce a čištění dat z HTML

    Váš Web Help obsahuje spoustu HTML značek (<div>, <p>, <a>, <table>), navigačních prvků (menu, patičky), skriptů a stylů. Pro AI potřebujeme jen samotný smysluplný text.

    Nástroje: K tomu se perfektně hodí knihovna Beautiful Soup pro Python. Umožňuje procházet HTML strukturu a vybírat jen to, co potřebujeme.

    Postup:

    1. Procházení složek: Vytvoříme skript, který projde všechny soubory a podsložky ve vaší kořenové složce s Web Helpem.
    2. Načtení HTML: Pro každý soubor s koncovkou .html nebo .htm načteme jeho obsah.
    3. Parsování a extrakce textu: Pomocí Beautiful Soup odstraníme HTML značky.
    4. Čištění: Odstraníme nadbytečné bílé znaky, prázdné řádky a text, který nechceme (např. text z navigace "Další stránka", "Předchozí", "Obsah").

    Jak identifikovat hlavní obsah? Nejlepší je otevřít si několik stránek Helpu v prohlížeči a pomocí vývojářských nástrojů (pravé tlačítko -> "Prozkoumat" nebo F12) zjistit, jestli má hlavní textový obsah nějaký společný identifikátor, např. <div id="main-content"> nebo <article class="help-topic">. To nám umožní extrahovat text mnohem přesněji.

    Příklad kódu v Pythonu (extrakce):

    Nejprve si nainstalujte potřebné knihovny:

    pip install beautifulsoup4 lxml
    

    A zde je samotný skript:

    import os
    from bs4 import BeautifulSoup
    import re
    
    def extract_text_from_html(file_path):
        """
        Načte HTML soubor, extrahuje a vyčistí hlavní textový obsah.
        """
        try:
            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                html_content = f.read()
                
            soup = BeautifulSoup(html_content, 'lxml')
            
            # --- ZDE JE KLÍČOVÉ MÍSTO PRO ÚPRAVU ---
            # Pokusíme se najít hlavní obsah. Pokud selže, vezmeme celý text.
            # Upravte 'div', {'id': 'main-content'} podle struktury vašeho Helpu!
            main_content = soup.find('div', {'id': 'main-content'}) # Příklad
            if not main_content:
                main_content = soup.body # Pokud nenajdeme, vezmeme celý <body>
    
            if main_content:
                # Získání textu
                text = main_content.get_text(separator=' ', strip=True)
                
                # Základní čištění: nahrazení více mezer jednou
                text = re.sub(r'\s+', ' ', text)
                
                return text
            
            return None
    
        except Exception as e:
            print(f"Chyba při zpracování souboru {file_path}: {e}")
            return None
    
    def process_help_directory(root_dir):
        """
        Projide celý adresář s Web Helpem a extrahuje text ze všech HTML souborů.
        """
        all_texts = []
        for dirpath, _, filenames in os.walk(root_dir):
            for filename in filenames:
                if filename.lower().endswith(('.html', '.htm')):
                    file_path = os.path.join(dirpath, filename)
                    print(f"Zpracovávám: {file_path}")
                    
                    text = extract_text_from_html(file_path)
                    if text:
                        # Uložíme text spolu s názvem souboru (jako metadat)
                        all_texts.append({'source': file_path, 'content': text})
                        
        return all_texts
    
    # --- Spuštění ---
    # Zadejte cestu ke kořenové složce vašeho Web Helpu
    HELP_ROOT_DIRECTORY = 'cesta/k/vasemu/webhelpu' 
    extracted_data = process_help_directory(HELP_ROOT_DIRECTORY)
    
    # Zobrazíme si výsledek pro první soubor
    if extracted_data:
        print("\n--- Příklad extrahovaných dat ---")
        print(f"Zdroj: {extracted_data[0]['source']}")
        print(f"Obsah: {extracted_data[0]['content'][:500]}...") # Ukázka prvních 500 znaků
    
    # Data můžete uložit do souboru pro další použití
    # import json
    # with open('extracted_help_content.json', 'w', encoding='utf-8') as f:
    #     json.dump(extracted_data, f, ensure_ascii=False, indent=4)
    

    Fáze 2: Příprava dat pro AI (Přístup RAG)

    Nyní máme hromadu textu. Trénovat vlastní model od nuly (fine-tuning) je pro tento účel drahé, složité a často zbytečné. Mnohem efektivnější je moderní přístup zvaný Retrieval-Augmented Generation (RAG).

    Princip RAG (přirovnatelný ke zkoušce s otevřenou knihou):

    1. Indexace (předem):

      • Segmentace (Chunking): Dlouhé texty rozdělíme na menší, logické části (tzv. "chunky"). To je důležité, protože modely mají omezenou paměť (context window).
      • Vytvoření vektorů (Embeddings): Každý chunk převedeme pomocí speciálního modelu na sadu čísel (vektor). Tento vektor reprezentuje sémantický význam textu. Podobné texty budou mít podobné vektory.
      • Uložení do vektorové databáze: Všechny chunky a jejich vektory uložíme do speciální databáze, která umí bleskově vyhledávat podle podobnosti vektorů.
    2. Dotazování (v reálném čase):

      • Uživatel položí dotaz (např. "Jak resetuji heslo?").
      • Dotaz se také převede na vektor.
      • Vektorová databáze najde několik nejrelevantnějších chunků z dokumentace (těch, jejichž vektory jsou nejblíže vektoru dotazu).
      • Tyto nalezené chunky se vloží do promptu pro velký jazykový model (jako GPT-4, Llama 3 atd.) spolu s původním dotazem.
      • Prompt vypadá asi takto: "Odpověz na následující otázku pouze na základě poskytnutého kontextu. Kontext: [zde se vloží text nejrelevantnějších chunků]. Otázka: Jak resetuji heslo?"
      • Model pak vygeneruje odpověď založenou přímo na vaší dokumentaci.

    Výhody RAG:

    • Přesnost: Odpovědi jsou založené na faktech z vaší dokumentace.
    • Snížení halucinací: Model si nevymýšlí, protože má zdrojové texty.
    • Snadná aktualizace: Když změníte Help, stačí znovu zaindexovat data, nemusíte přetrénovávat celý model.
    • Možnost citace zdrojů: Víte přesně, z které části Helpu odpověď pochází.

    Fáze 3: Praktická implementace agenta pomocí LangChain

    Pro zjednodušení celého RAG procesu použijeme knihovnu LangChain, která vše skvěle propojuje.

    Potřebné knihovny:

    # Základní framework
    pip install langchain
    # Propojení s modely OpenAI (nebo jinými)
    pip install langchain-openai
    # Načítání HTML
    pip install langchain-community
    # Segmentace textu
    pip install langchain-text-splitters
    # Vektorová databáze (lokální, jednoduchá)
    pip install faiss-cpu
    # Pro převod textu na vektory (embeddings)
    pip install sentence-transformers
    

    Poznámka: faiss-cpu je pro lokální použití. Pro produkční nasazení se používají databáze jako ChromaDB, Pinecone nebo jiné.

    Kompletní kód (extrakce + RAG agent):

    import os
    from langchain_community.document_loaders import DirectoryLoader, UnstructuredHTMLLoader
    from langchain_text_splitters import RecursiveCharacterTextSplitter
    from langchain_community.vectorstores import FAISS
    from langchain_community.embeddings import HuggingFaceEmbeddings
    from langchain.chains.combine_documents import create_stuff_documents_chain
    from langchain.chains import create_retrieval_chain
    from langchain_core.prompts import ChatPromptTemplate
    from langchain_openai import ChatOpenAI # Můžete nahradit jiným modelem
    
    # --- 1. Načtení a příprava dat ---
    
    # Cesta ke kořenové složce vašeho Web Helpu
    HELP_ROOT_DIRECTORY = 'cesta/k/vasemu/webhelpu'
    
    # LangChain má vlastní načítání HTML, které je jednodušší
    # Glob vzor '**/*.html' projde všechny podsložky a načte všechny .html soubory
    loader = DirectoryLoader(
        HELP_ROOT_DIRECTORY, 
        glob="**/*.html", 
        loader_cls=UnstructuredHTMLLoader, # Použije Unstructured pro parsování
        show_progress=True,
        use_multithreading=True
    )
    
    print("Načítám dokumenty...")
    docs = loader.load()
    print(f"Načteno {len(docs)} dokumentů.")
    
    # Rozdělení dokumentů na menší chunky
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
    splits = text_splitter.split_documents(docs)
    print(f"Dokumenty rozděleny na {len(splits)} segmentů (chunků).")
    
    # --- 2. Vytvoření a uložení vektorové databáze ---
    
    # Použijeme volně dostupný model pro embeddings, který běží lokálně
    # Stáhne se automaticky při prvním spuštění
    print("Vytvářím embeddings a vektorovou databázi...")
    embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
    
    # Vytvoření vektorové databáze FAISS z našich chunků
    # Tento krok může chvíli trvat v závislosti na množství dat
    vectorstore = FAISS.from_documents(documents=splits, embedding=embeddings)
    
    # Databázi si můžeme uložit na disk pro pozdější rychlé načtení
    # vectorstore.save_local("faiss_index_webhelp")
    # a načíst takto:
    # vectorstore = FAISS.load_local("faiss_index_webhelp", embeddings)
    print("Vektorová databáze je připravena.")
    
    # --- 3. Vytvoření RAG řetězce (chain) ---
    
    # Zde si nastavíte svůj jazykový model. Pro OpenAI potřebujete API klíč.
    # Klíč nastavte jako systémovou proměnnou: os.environ["OPENAI_API_KEY"] = "váš_klíč"
    # Lze použít i jiné modely (lokální přes Ollama, Google, Anthropic atd.)
    os.environ["OPENAI_API_KEY"] = "sk-..." # Vložte svůj klíč
    llm = ChatOpenAI(model="gpt-4o", temperature=0.2) 
    
    # Vytvoření retrieveru, který bude hledat ve vektorové databázi
    retriever = vectorstore.as_retriever(search_kwargs={"k": 5}) # Hledej 5 nejrelevantnějších
    
    # Šablona promptu, která říká modelu, jak se má chovat
    prompt = ChatPromptTemplate.from_template("""
    Odpověz na otázku uživatele pouze na základě poskytnutého kontextu.
    Pokud odpověď v kontextu nenajdeš, napiš: "Tuto informaci jsem v dokumentaci nenašel."
    Buď stručný a věcný.
    
    Kontext:
    {context}
    
    Otázka: {input}
    
    Odpověď:
    """)
    
    # Sestavení řetězce, který propojí prompt s LLM
    document_chain = create_stuff_documents_chain(llm, prompt)
    
    # Sestavení finálního řetězce, který nejprve najde dokumenty (retrieval) a pak je předá dál
    retrieval_chain = create_retrieval_chain(retriever, document_chain)
    
    # --- 4. Dotazování ---
    
    print("\n--- Agent je připraven. Zeptejte se na něco: ---")
    while True:
        query = input("Váš dotaz (napište 'konec' pro ukončení): ")
        if query.lower() == 'konec':
            break
        
        response = retrieval_chain.invoke({"input": query})
        
        print("\nOdpověď AI:")
        print(response["answer"])
        
        # Můžeme si zobrazit i zdroje, ze kterých čerpal
        print("\nZdroje:")
        for doc in response["context"]:
            # Metadata obsahují zdrojový soubor
            print(f" - {doc.metadata.get('source', 'Neznámý zdroj')}")
        print("-" * 20)
    

    Shrnutí a doporučení

    1. Začněte s Fází 1: Upravte první skript tak, aby co nejlépe extrahoval čistý text z vašeho konkrétního Web Helpu. Klíčové je správně identifikovat hlavní obsahový blok.
    2. Použijte RAG: Pro váš případ je to nejlepší a nejefektivnější metoda.
    3. Implementujte s LangChain: Ušetří vám to obrovské množství práce. Kód výše je téměř kompletní řešení, které stačí jen přizpůsobit (cesta k Helpu, API klíč).
    4. Experimentujte s modely: Můžete začít s OpenAI a pokud budete potřebovat řešení, které běží kompletně lokálně (kvůli citlivosti dat), můžete ChatOpenAI nahradit modelem běžícím přes Ollama (např. Llama 3 nebo Mistral).

    Tento postup vám dá robustního AI agenta, který bude spolehlivě odpovídat na dotazy ohledně vašeho systému na základě dodané dokumentace.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.