Przeszukiwanie sieci Web i funkcje RAG dla agentów AI i asystentów kodowania AI

Potężna implementacja protokołu Model Context Protocol (MCP) zintegrowana z Crawl4AI i Supabase w celu zapewnienia agentom AI i asystentom kodowania AI zaawansowanych funkcji przeszukiwania sieci i RAG.

Dzięki temu serwerowi MCP możesz zeskrobać wszystko, a następnie wykorzystać tę wiedzę w dowolnym miejscu dla RAG.

Głównym celem jest wprowadzenie tego serwera MCP do Archon, ponieważ rozwijam go tak, aby stał się bardziej silnikiem wiedzy dla asystentów kodowania AI do tworzenia agentów AI. Ta pierwsza wersja serwera Crawl4AI/RAG MCP zostanie wkrótce znacznie ulepszona, zwłaszcza dzięki czemu będzie bardziej konfigurowalny, dzięki czemu będzie można używać różnych modeli osadzania i uruchamiać wszystko lokalnie za pomocą Ollamy.

Potraktuj to repozytorium GitHub jako środowisko testowe, dlatego nie zajmowałem się jeszcze zbyt aktywnie problemami i żądaniami ściągnięcia. Na pewno jednak to zrobię, gdy wprowadzę to do Archon V2!

Ten serwer MCP udostępnia narzędzia, które umożliwiają agentom sztucznej inteligencji przeszukiwanie witryn internetowych, przechowywanie zawartości w wektorowej bazie danych (Supabase) i wykonywanie operacji RAG na przeszukanej zawartości. Jest on zgodny z najlepszymi praktykami tworzenia serwerów MCP na podstawie szablonu serwera MCP Mem0, który wcześniej udostępniłem na moim kanale.

Serwer zawiera kilka zaawansowanych strategii RAG, które można włączyć w celu poprawy jakości pobierania:

• Osadzanie kontekstowe w celu wzbogacenia zrozumienia semantycznego
• Wyszukiwanie hybrydowe łączące wyszukiwanie wektorowe i wyszukiwanie słów kluczowych
• Agentic RAG do ekstrakcji specjalistycznego przykładu kodu
• Ponowne klasyfikowanie w celu zwiększenia trafności wyników przy użyciu modeli koderów krzyżowych
• Graf wiedzy do wykrywania halucynacji AI i analizy kodu repozytorium

Zapoznaj się z poniższą sekcją Konfiguracja, aby uzyskać szczegółowe informacje na temat włączania i konfigurowania tych strategii.

Serwer Crawl4AI RAG MCP to dopiero początek. Oto, dokąd zmierzamy:

1. Integracja z Archonem: Budowanie tego systemu bezpośrednio w Archon w celu stworzenia kompleksowego silnika wiedzy dla asystentów kodowania AI w celu budowania lepszych agentów AI.

2. Wiele modeli osadzania: Rozszerza się poza OpenAI w celu obsługi różnych modeli osadzania, w tym możliwości uruchamiania wszystkiego lokalnie za pomocą Ollama w celu uzyskania pełnej kontroli i prywatności.

3. Zaawansowane strategie RAG: Implementacja wyrafinowanych technik wyszukiwania, takich jak wyszukiwanie kontekstowe, późne fragmentowanie i inne, aby wyjść poza podstawowe „naiwne wyszukiwania” i znacznie zwiększyć moc i precyzję systemu RAG, zwłaszcza gdy integruje się on z Archonem.

4. Ulepszona strategia fragmentowania: Implementacja podejścia do fragmentowania inspirowanego Context 7, które koncentruje się na przykładach i tworzy odrębne, semantycznie znaczące sekcje dla każdego fragmentu, poprawiając precyzję pobierania.

5. Optymalizacja wydajności: Zwiększenie szybkości przeszukiwania i indeksowania, aby bardziej realistyczne było „szybkie” indeksowanie nowej dokumentacji, a następnie wykorzystanie jej w tym samym monicie w asystencie kodowania AI.

• Inteligentne wykrywanie adresów URL: Automatycznie wykrywa i obsługuje różne typy adresów URL (zwykłe strony internetowe, mapy witryn, pliki tekstowe)
• Indeksowanie rekurencyjne: podąża za linkami wewnętrznymi w celu odkrywania treści
• Przetwarzanie równoległe: Wydajne przeszukiwanie wielu stron jednocześnie
• Fragmentowanie treści: Inteligentnie dzieli zawartość według nagłówków i rozmiaru w celu lepszego przetwarzania
• Wyszukiwanie wektorowe: Wykonuje RAG na przeszukanej zawartości, opcjonalnie filtrując według źródła danych w celu uzyskania precyzji.
• Pobieranie źródła: Pobieranie źródeł dostępnych do filtrowania w celu kierowania procesem RAG

Serwer zapewnia niezbędne narzędzia do indeksowania i wyszukiwania:

1. crawl_single_page: Szybkie przeszukiwanie pojedynczej strony internetowej i zapisywanie jej zawartości w wektorowej bazie danych
2. smart_crawl_url: inteligentne indeksowanie całej witryny na podstawie podanego typu adresu URL (mapa witryny, llms-full.txt lub zwykła strona internetowa, która ma być indeksowana rekurencyjnie)
3. get_available_sources: Pobierz listę wszystkich dostępnych źródeł (domen) w bazie danych
4. perform_rag_query: Wyszukiwanie odpowiedniej zawartości przy użyciu wyszukiwania semantycznego z opcjonalnym filtrowaniem źródeł

5. search_code_examples (wymagane): Wyszukaj przykłady kodu i ich podsumowania w przeszukanej dokumentacji. To narzędzie zapewnia ukierunkowane pobieranie fragmentów kodu dla asystentów kodowania AI.USE_AGENTIC_RAG=true

6. parse_github_repository: Przeanalizuj repozytorium GitHub w grafie wiedzy Neo4j, wyodrębniając klasy, metody, funkcje i ich relacje w celu wykrywania halucynacji
7. check_ai_script_hallucinations: Analizowanie skryptów języka Python pod kątem halucynacji sztucznej inteligencji przez sprawdzanie poprawności importów, wywołań metod i użycia klas względem grafu wiedzy
8. query_knowledge_graph: Eksploruj graf wiedzy Neo4j i wysyłaj do niego zapytania za pomocą poleceń, takich jak , , i niestandardowych zapytań Cypherreposclassesmethods

• Docker/Docker Desktop, jeśli serwer MCP jest uruchomiony jako kontener (zalecane)
• Python 3.12+, jeśli serwer MCP jest uruchamiany bezpośrednio przez uv
• Supabase (baza danych dla RAG)
• Klucz API OpenAI (do generowania osadzeń)
• Neo4j (opcjonalnie, dla funkcjonalności grafu wiedzy) – zobacz sekcję Ustawienia grafu wiedzy

1. Sklonuj to repozytorium:

   git clone https://github.com/coleam00/mcp-crawl4ai-rag.git
   cd mcp-crawl4ai-rag

    

2. Skompiluj obraz platformy Docker:

   docker build -t mcp/crawl4ai-rag --build-arg PORT=8051 .

    

3. Utwórz plik na podstawie poniższej sekcji konfiguracji.env

1. Sklonuj to repozytorium:

   git clone https://github.com/coleam00/mcp-crawl4ai-rag.git
   cd mcp-crawl4ai-rag

    

2. Zainstaluj uv, jeśli go nie masz:

   pip install uv

    

3. Tworzenie i aktywowanie środowiska wirtualnego:

   uv venv
   .venv\Scripts\activate
   # on Mac/Linux: source .venv/bin/activate

    

4. Zainstaluj zależności:

   uv pip install -e .
   crawl4ai-setup

    

5. Utwórz plik na podstawie poniższej sekcji konfiguracji.env

Przed uruchomieniem serwera należy skonfigurować bazę danych z rozszerzeniem pgvector:

1. Przejdź do Edytora SQL na pulpicie nawigacyjnym Supabase (w razie potrzeby najpierw utwórz nowy projekt)

2. Utwórz nowe zapytanie i wklej zawartość crawled_pages.sql

3. Uruchom kwerendę, aby utworzyć niezbędne tabele i funkcje

Aby włączyć funkcje wykrywania halucynacji AI i analizy repozytorium, musisz skonfigurować Neo4j.

Ponadto implementacja grafu wiedzy nie jest jeszcze w pełni kompatybilna z Dockerem, więc polecam teraz uruchomienie bezpośrednio przez uv, jeśli chcesz korzystać z wykrywania halucynacji na serwerze MCP!

Aby zainstalować Neo4j:

Najprostszym sposobem na uruchomienie Neo4j lokalnie jest skorzystanie z lokalnego pakietu AI — wyselekcjonowanej kolekcji lokalnych usług AI, w tym Neo4j:

1. Sklonuj lokalny pakiet AI:

   git clone https://github.com/coleam00/local-ai-packaged.git
   cd local-ai-packaged

    

2. Uruchom Neo4j: Postępuj zgodnie z instrukcjami w repozytorium lokalnych pakietów sztucznej inteligencji, aby uruchomić Neo4j za pomocą narzędzia Docker Compose

3. Domyślne szczegóły połączenia:

   • URI: bolt://localhost:7687
   • Nazwa użytkownika: neo4j
   • Hasło: Zapoznaj się z dokumentacją lokalnego pakietu sztucznej inteligencji, aby uzyskać domyślne hasło

Alternatywnie zainstaluj Neo4j bezpośrednio:

1. Zainstaluj Neo4j Desktop: Pobierz z neo4j.com/download

2. Utwórz nową bazę danych:

   • Otwórz pulpit Neo4j
   • Tworzenie nowego projektu i bazy danych
   • Ustawianie hasła dla użytkownikaneo4j
   • Uruchamianie bazy danych

3. Zanotuj szczegóły połączenia:

   • Identyfikator URI: (domyślnie)bolt://localhost:7687
   • Nazwa użytkownika: (domyślnie)neo4j
   • Hasło: Cokolwiek ustawisz podczas tworzenia

Utwórz plik w katalogu głównym projektu z następującymi zmiennymi:.env

# MCP Server Configuration
HOST=0.0.0.0
PORT=8051
TRANSPORT=sse

# OpenAI API Configuration
OPENAI_API_KEY=your_openai_api_key

# LLM for summaries and contextual embeddings
MODEL_CHOICE=gpt-4.1-nano

# RAG Strategies (set to "true" or "false", default to "false")
USE_CONTEXTUAL_EMBEDDINGS=false
USE_HYBRID_SEARCH=false
USE_AGENTIC_RAG=false
USE_RERANKING=false
USE_KNOWLEDGE_GRAPH=false

# Supabase Configuration
SUPABASE_URL=your_supabase_project_url
SUPABASE_SERVICE_KEY=your_supabase_service_key

# Neo4j Configuration (required for knowledge graph functionality)
NEO4J_URI=bolt://localhost:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=your_neo4j_password

Serwer MCP Crawl4AI RAG obsługuje cztery potężne strategie RAG, które można włączać niezależnie:

Po włączeniu ta strategia rozszerza osadzanie każdego fragmentu o dodatkowy kontekst z całego dokumentu. System przekazuje zarówno cały dokument, jak i określony fragment do LLM (skonfigurowanego za pomocą ) w celu wygenerowania wzbogaconego kontekstu, który jest osadzany wraz z zawartością fragmentu.MODEL_CHOICE

• Kiedy używać: włącz tę opcję, jeśli potrzebujesz precyzyjnego pobierania, gdy kontekst ma znaczenie, na przykład dokumentacja techniczna, w której terminy mogą mieć różne znaczenia w różnych sekcjach.
• Kompromisy: Wolniejsze indeksowanie ze względu na wywołania LLM dla każdego fragmentu, ale znacznie lepsza dokładność pobierania.
• Koszt: Dodatkowe wywołania interfejsu API LLM podczas indeksowania.

Łączy tradycyjne wyszukiwanie słów kluczowych z semantycznym wyszukiwaniem wektorowym, aby zapewnić bardziej kompleksowe wyniki. System wykonuje oba wyszukiwania równolegle i inteligentnie łączy wyniki, nadając priorytet dokumentom, które pojawiają się w obu zestawach wyników.

• Kiedy używać: włącz tę opcję, gdy użytkownicy mogą wyszukiwać przy użyciu określonych terminów technicznych, nazw funkcji lub gdy dokładne dopasowania słów kluczowych są ważne wraz ze zrozumieniem semantycznym.
• Kompromisy: Nieco wolniejsze zapytania, ale bardziej solidne wyniki, zwłaszcza w przypadku treści technicznych.
• Koszt: Brak dodatkowych kosztów interfejsu API, tylko narzut obliczeniowy.

Umożliwia wyodrębnianie i przechowywanie specjalistycznych przykładów kodu. Podczas przeszukiwania dokumentacji system identyfikuje bloki kodu (≥300 znaków), wyodrębnia je wraz z otaczającym kontekstem, generuje podsumowania i przechowuje je w osobnej tabeli wektorowej bazy danych zaprojektowanej specjalnie do wyszukiwania kodu.

• Kiedy używać: Niezbędne dla asystentów kodowania AI, którzy muszą znaleźć konkretne przykłady kodu, wzorce implementacji lub przykłady użycia z dokumentacji.
• Kompromisy: Znacznie wolniejsze indeksowanie ze względu na wyodrębnianie kodu i podsumowywanie wymaga więcej miejsca w pamięci masowej.
• Koszt: Dodatkowe wywołania interfejsu API LLM do podsumowania każdego przykładu kodu.
• Korzyści: Udostępnia dedykowane narzędzie, którego agenci sztucznej inteligencji mogą używać do znajdowania określonych implementacji kodu.search_code_examples

Stosuje ponowne klasyfikowanie kodera krzyżowego do wyników wyszukiwania po początkowym pobraniu. Używa uproszczonego modelu kodera krzyżowego () do oceny każdego wyniku względem oryginalnego zapytania, a następnie zmienia kolejność wyników według istotności.cross-encoder/ms-marco-MiniLM-L-6-v2

• Kiedy używać: włącz tę opcję, gdy precyzja wyszukiwania ma kluczowe znaczenie i potrzebujesz najtrafniejszych wyników u góry. Jest to szczególnie przydatne w przypadku złożonych zapytań, w których samo podobieństwo semantyczne może nie przechwytywać intencji zapytania.
• Kompromisy: Dodaje ~100-200 ms do zapytań wyszukiwania w zależności od liczby wyników, ale znacznie poprawia kolejność wyników.
• Koszt: Brak dodatkowych kosztów interfejsu API — używa modelu lokalnego, który działa na procesorze CPU.
• Korzyści: Lepsza trafność wyników, szczególnie w przypadku złożonych zapytań. Działa zarówno ze zwykłym wyszukiwaniem RAG, jak i wyszukiwaniem przykładowego kodu.

Umożliwia wykrywanie halucynacji AI i analizę repozytorium przy użyciu grafów wiedzy Neo4j. Po włączeniu system może analizować repozytoria GitHub w grafowej bazie danych i weryfikować kod wygenerowany przez sztuczną inteligencję względem rzeczywistych struktur repozytorium. (NIE w pełni kompatybilny jeszcze z Dockerem, polecam uruchomienie przez uv)

• Kiedy używać: Włącz tę opcję dla asystentów kodowania AI, którzy muszą weryfikować wygenerowany kod względem rzeczywistych implementacji lub gdy chcesz wykryć, kiedy modele sztucznej inteligencji halucynują nieistniejące metody, klasy lub nieprawidłowe wzorce użycia.
• Kompromisy: Wymaga konfiguracji Neo4j i dodatkowych zależności. Analizowanie repozytorium może być powolne w przypadku dużych baz kodu, a walidacja wymaga wstępnego indeksowania repozytoriów.
• Koszt: Brak dodatkowych kosztów API do walidacji, ale wymaga infrastruktury Neo4j (można korzystać z bezpłatnej instalacji lokalnej lub AuraDB w chmurze).
• Korzyści: Udostępnia trzy zaawansowane narzędzia: do indeksowania baz kodu, do weryfikowania kodu generowanego przez sztuczną inteligencję i do eksplorowania indeksowanych repozytoriów.parse_github_repositorycheck_ai_script_hallucinationsquery_knowledge_graph

Teraz możesz powiedzieć asystentowi kodowania AI, aby dodał repozytorium GitHub języka Python do grafu wiedzy, na przykład:

„Dodaj https://github.com/pydantic/pydantic-ai.git do grafu wiedzy”

Upewnij się, że adres URL repozytorium kończy się ciągiem .git.

Możesz także poprosić asystenta kodowania AI o sprawdzenie, czy nie ma halucynacji za pomocą skryptów, które właśnie utworzył, lub możesz ręcznie uruchomić polecenie:

python knowledge_graphs/ai_hallucination_detector.py [full path to your script to analyze]

Dokumentacja ogólna RAG:

USE_CONTEXTUAL_EMBEDDINGS=false
USE_HYBRID_SEARCH=true
USE_AGENTIC_RAG=false
USE_RERANKING=true

W przypadku asystenta kodowania AI z przykładami kodu:

USE_CONTEXTUAL_EMBEDDINGS=true
USE_HYBRID_SEARCH=true
USE_AGENTIC_RAG=true
USE_RERANKING=true
USE_KNOWLEDGE_GRAPH=false

Dla asystenta kodowania AI z wykrywaniem halucynacji:

USE_CONTEXTUAL_EMBEDDINGS=true
USE_HYBRID_SEARCH=true
USE_AGENTIC_RAG=true
USE_RERANKING=true
USE_KNOWLEDGE_GRAPH=true

Dla szybkiego, podstawowego RAG:

USE_CONTEXTUAL_EMBEDDINGS=false
USE_HYBRID_SEARCH=true
USE_AGENTIC_RAG=false
USE_RERANKING=false
USE_KNOWLEDGE_GRAPH=false

docker run --env-file .env -p 8051:8051 mcp/crawl4ai-rag

uv run src/crawl4ai_mcp.py

Serwer uruchomi się i będzie nasłuchiwał na skonfigurowanym hoście i porcie.

Gdy serwer jest uruchomiony z transportem SSE, możesz połączyć się z nim przy użyciu tej konfiguracji:

{
  "mcpServers": {
    "crawl4ai-rag": {
      "transport": "sse",
      "url": "http://localhost:8051/sse"
    }
  }
}

Uwaga dla użytkowników Windsurfingu: Użyj zamiast w swojej konfiguracji:serverUrlurl

{
  "mcpServers": {
    "crawl4ai-rag": {
      "transport": "sse",
      "serverUrl": "http://localhost:8051/sse"
    }
  }
}

 

Uwaga dla użytkowników platformy Docker: Użyj zamiast, jeśli klient jest uruchomiony w innym kontenerze. Będzie to miało zastosowanie, jeśli używasz tego serwera MCP w n8n!host.docker.internallocalhost

Uwaga dla użytkowników Claude Code:

claude mcp add-json crawl4ai-rag '{"type":"http","url":"http://localhost:8051/sse"}' --scope user

Dodaj ten serwer do konfiguracji MCP dla Claude Desktop, Windsurf lub dowolnego innego klienta MCP:

{
  "mcpServers": {
    "crawl4ai-rag": {
      "command": "python",
      "args": ["path/to/crawl4ai-mcp/src/crawl4ai_mcp.py"],
      "env": {
        "TRANSPORT": "stdio",
        "OPENAI_API_KEY": "your_openai_api_key",
        "SUPABASE_URL": "your_supabase_url",
        "SUPABASE_SERVICE_KEY": "your_supabase_service_key",
        "USE_KNOWLEDGE_GRAPH": "false",
        "NEO4J_URI": "bolt://localhost:7687",
        "NEO4J_USER": "neo4j",
        "NEO4J_PASSWORD": "your_neo4j_password"
      }
    }
  }
}

{
  "mcpServers": {
    "crawl4ai-rag": {
      "command": "docker",
      "args": ["run", "--rm", "-i", 
               "-e", "TRANSPORT", 
               "-e", "OPENAI_API_KEY", 
               "-e", "SUPABASE_URL", 
               "-e", "SUPABASE_SERVICE_KEY",
               "-e", "USE_KNOWLEDGE_GRAPH",
               "-e", "NEO4J_URI",
               "-e", "NEO4J_USER",
               "-e", "NEO4J_PASSWORD",
               "mcp/crawl4ai"],
      "env": {
        "TRANSPORT": "stdio",
        "OPENAI_API_KEY": "your_openai_api_key",
        "SUPABASE_URL": "your_supabase_url",
        "SUPABASE_SERVICE_KEY": "your_supabase_service_key",
        "USE_KNOWLEDGE_GRAPH": "false",
        "NEO4J_URI": "bolt://localhost:7687",
        "NEO4J_USER": "neo4j",
        "NEO4J_PASSWORD": "your_neo4j_password"
      }
    }
  }
}

System grafów wiedzy przechowuje strukturę kodu repozytorium w Neo4j z następującymi komponentami:

• parse_repo_into_neo4j.py: klonuje i analizuje repozytoria GitHub, wyodrębniając klasy, metody, funkcje i importy języka Python do węzłów i relacji Neo4j
• ai_script_analyzer.py: Analizuje skrypty języka Python przy użyciu AST do wyodrębniania importów, wystąpień klas, wywołań metod i użycia funkcji
• knowledge_graph_validator.py: Weryfikuje kod wygenerowany przez sztuczną inteligencję względem grafu wiedzy w celu wykrycia halucynacji (nieistniejących metod, nieprawidłowych parametrów itp.)
• hallucination_reporter.py: Generuje kompleksowe raporty o wykrytych halucynacjach z ocenami ufności i zaleceniami
• query_knowledge_graph.py: Interaktywne narzędzie CLI do eksplorowania grafu wiedzy (funkcjonalność teraz zintegrowana z narzędziami MCP)

Baza danych Neo4j przechowuje strukturę kodu jako:

Węzłów:

• Repository: Repozytoria GitHub
• File: Pliki Pythona w repozytoriach
• Class: Klasy Pythona z metodami i atrybutami
• Method: Metody klas z informacjami o parametrach
• Function: Funkcje autonomiczne
• Attribute: Atrybuty klasy

Relacje:

• Repository -[:ZAWIERA]-> File
• File -[:D EFINY]-> Class
• File -[:D EFINY]-> Function
• Class -[:HAS_METHOD]-> Method
• Class -[:HAS_ATTRIBUTE]-> Attribute

1. Analizowanie repozytorium: Użyj narzędzia do klonowania i analizowania repozytoriów typu open sourceparse_github_repository
2. Walidacja kodu: używanie narzędzia do weryfikowania skryptów języka Python generowanych przez sztuczną inteligencjęcheck_ai_script_hallucinations
3. Eksploracja wiedzy: Użyj narzędzia do eksplorowania dostępnych repozytoriów, klas i metodquery_knowledge_graph

Ta implementacja stanowi podstawę do tworzenia bardziej złożonych serwerów MCP z możliwościami przeszukiwania sieci Web. Aby utworzyć własny:

1. Dodaj własne narzędzia, tworząc metody za pomocą dekoratora@mcp.tool()
2. Utwórz własną funkcję długości życia, aby dodać własne zależności
3. Zmodyfikuj plik dla wszystkich potrzebnych funkcji pomocniczychutils.py
4. Rozszerz możliwości indeksowania, dodając bardziej wyspecjalizowane roboty indeksujące