In den letzten Monaten hatte ich die Gelegenheit, mich in die Aufgabe einzutauchen, APIs und Backend -Systeme für den Konsum durch LLMs anzupassen, insbesondere mit dem MCP -Protokoll. Anfangs erwartete ich, dass die Erfahrung nicht anders ist als alle anderen ähnlichen Entwicklungsprojekte, die ich in der Vergangenheit durchgeführt habe. Ich struggle jedoch fasziniert zu entdecken, dass diese autonomen Kunden eine neue Artwork von Kreatur sind. Infolgedessen erforderte sich die Entwicklung von APIs, um den größten Wert aus der Agenteninteraktion zu erzielen, mehr als nur zugänglich.

Dieser Beitrag ist ein Ergebnis meiner Experimente und Feldtests, hoffentlich kann er für andere Praktiker nützlich sein.

Die Kraft und Fluch der Autonomie

Wir Entwickler werden an Instruments und Automatisierungsprozesse der dritten Social gathering gewöhnt, die mit den Anwendungs-APIs interagieren. Unsere Schnittstellen haben sich daher um Finest Practices entwickelt, die diese Anwendungsfälle am besten unterstützen. Transaktions-, versionierte, vertragsgetriebene APIs, die zur Durchsetzung von Vorwärts-/Rückwärtskompatibilität und für die Effizienz aufgebaut wurden. Dies sind alles wichtige Anliegen, die in der Priorität zweitrangig sind und oft einfach irrelevant sind, wenn sie den autonomen Benutzer berücksichtigen.

Bei Agenten als Kunden müssen sich keine Sorgen über die Kompatibilität für die Rückwärts-/Vorwärtsbewegung machen, da jede Sitzung staatenlos und einzigartig ist. Das Modell untersucht, wie man bei jedem Entdeckung Instruments verwendet und an der richtigen Kombination von API -Aufrufen ankommt, um sein Ziel zu erreichen. So begeistert dieser Agent auch sein magazine, es wird jedoch auch nach einigen wenigen versagten Versuchen aufgeben, es sei denn, es gibt angemessene Anreize und Richtlinien.

Noch wichtiger ist, dass dies ohne solche Hinweise bei der API -Anruf erfolgreich sein könnte, aber seine Ziele nicht erreicht. Im Gegensatz zu Skriptautomatik oder erfahrenen Entwicklern verfügt es nur über die API -Dokumentation und die Antworten, um herauszufinden, wie die Ziele erreicht werden können. Die dynamische Natur seiner Reaktion ist sowohl ein Segen als auch ein Fluch, da diese beiden Quellen auch die Summe des Wissens sind, auf die er zurückgreifen kann, um wirksam zu sein.

Gesprächsgetriebene APIs

Ich hatte zuerst erkannt, dass der Agent eine andere Artwork von Design benötigen würde, während einige Fälle, in denen der Agent nicht in die gewünschte Ergebnisse gelangen konnte, zu beheben. Ich habe MCP Software -Zugriff auf eine API zur Verfügung gestellt, die Nutzungsinformationen für jede Codefunktion basierend auf den Verfolgung von Daten bereitstellt. Manchmal schien es, dass der Agent es einfach nicht richtig benutzte. In der Interaktion genauer betrachtete das Modell das Software richtig und erhielt aus verschiedenen Gründen ein leeres Array als Antwort. Dieses Verhalten wäre 100% korrekt für einen ähnlichen Betrieb in unserer API.

Der Agent hatte jedoch Probleme zu verstehen, warum dies geschah. Nachdem es ein paar einfache Variationen ausprobiert hatte, gab es aufgegeben und beschloss, zu anderen Erforschungsmöglichkeiten zu übergehen. Für mich hat diese Interaktion eine verpasste Gelegenheit dargestellt. Niemand hatte schuld; Transaktionell struggle das Verhalten korrekt. Alle relevanten Exams würden bestehen, aber bei der Messung der Wirksamkeit dieser API stellten wir fest, dass die „Erfolgsrate“ lächerlich niedrig struggle.

Die Lösung stellte sich als einfach heraus, anstatt eine leere Antwort zurückzugeben, entschied ich mich für eine detailliertere Reihe von Anweisungen und Ideen:

var emptyResult = new NoDataFoundResponse()
{
    Message = @"There was no data discovered based mostly on the standards despatched.
        This might imply that the code isn't referred to as, or that it isn't manually instrumented 
        utilizing OTEL annotations.",
    SuggestedNextSteps = @"Urged steps: 
    1. Seek for endpoints (http, shoppers, jobs and so forth.) that use this perform. 
       Endpoints are often routinely instrumented with OTEL spans by the 
       libraries utilizing them.
    2. Strive calling this device utilizing the tactic and sophistication of the endpoint 
       itself or use the GetTraceForEndpoint device with the endpoint route. 
    3. Recommend handbook instrumentation for the precise technique relying on the language used within the undertaking
       and the present fashion of instrumentation used (annotations, code and so forth.)"

};

Anstatt nur die Ergebnisse an den Agenten zurückzugeben, versuchte ich, etwas zu tun, was Agenten oft versuchen werden – halten Sie das Gespräch am Laufen. Meine Wahrnehmung von API -Antworten änderten sich daher. Wenn sie von LLMs konsumiert werden, sind sie im Wesentlichen a Rückwärtsaufforderung. Eine beendete Interaktion ist eine Sackgasse. Alle Daten, die wir zum Agenten zurückkehren, bieten ihm die Möglichkeit, in seinem Untersuchungsprozess einen anderen Thread zu ziehen.

Hateoas, die APIs ‚Wählen Sie Ihr eigenes Abenteuer „

Als ich über die Philosophie dieses Ansatzes nachdachte, wurde mir klar, dass es etwas Vage bekannt struggle. Vor langer Zeit, als ich meine ersten Schritte zur Herstellung moderner REST -APIs machte, wurde ich in das Konzept von Hypermedia -APIs und Hateoas: Hypertext als Engine des Anwendungszustands eingeführt. Das Konzept wurde durch Fielding in seinem wegweisenden Weblog -Beitrag von 2008 umrissen REST-APIs müssen hypertextgetrieben sein. Ein Satz in diesem Beitrag hat mich damals völlig umgehauen:

„Übergänge des Anwendungsstatus müssen durch die Clientauswahl der serverbereiteten Auswahlmöglichkeiten gesteuert werden, die in den empfangenen Darstellungen vorhanden sind“

Mit anderen Worten, der Server kann unterrichten Der Consumer, was als nächstes zu tun ist, anstatt einfach die angeforderten Daten zurückzusenden. Das kanonische Beispiel ist eine einfache GET -Anfrage für eine bestimmte Ressource, wobei die Antwort Informationen zu Aktionen liefert, die der Consumer als nächstes auf diese Ressource annehmen kann. Eine selbstdokumentierende API, bei der der Kunde im Voraus nichts darüber wissen musste, außer einem einzigen Einstiegspunkt, aus dem ein Zweig mit Auswahlmöglichkeiten entsteht. Hier ist ein gutes Beispiel aus der Wikipedia Seite:

HTTP/1.1 200 OK

{
    "account": {
        "account_number": 12345,
        "steadiness": {
            "foreign money": "usd",
            "worth": 100.00
        },
        "hyperlinks": {
            "deposits": "/accounts/12345/deposits",
            "withdrawals": "/accounts/12345/withdrawals",
            "transfers": "/accounts/12345/transfers",
            "close-requests": "/accounts/12345/close-requests"
        }
    }
}

Zu dieser Zeit struggle ich fasziniert von diesem Konzept, das mich an das erinnerte, was allgemein als „Wählen Sie Ihr eigenes Abenteuer“ -Bücher oder „aus“ aus „aus.GameBooks‚. Dieses Style der Bücher, ein untrennbarer Bestandteil meiner Kindheit, leitete nicht einfach eine Geschichte weiter (oder lieferte eine API -Antwort durch diese Metapher), sondern gab dem Leser auch einen Schlüssel darüber, was die nächsten Optionen sind, die ihm verfügbar sind. Hypermedia Relaxation-APIs waren Selbstdokumentation und boten den Benutzern die Möglichkeit, den Standing der Anwendung und die für jede Entitäts- oder Prozessressource verfügbaren Vorgänge zu verstehen, ohne umfangreiche Dokumentation durchlesen zu müssen.

Hypermedia auf Steroiden

Eine Möglichkeit, Hypermedia APIs zu betrachten, besteht darin, dass er dem Benutzer als Teil der Antwort mehr Kontext bietet. Der Kontext ist für Agenten alles, und er muss mit den verfügbaren Optionen oder dem Betrieb sicherlich nicht aufhören. Eine API ist ein Interaktionspunkt, an dem der Kontext weitergeleitet und in einer Type bereitgestellt werden kann, die eine weitere Interaktion fördern würde. Schauen wir uns ein anderes Beispiel an!

Ein weiteres Software, an dem ich gearbeitet habe, ermöglicht das Modell zum Abrufen Laufzeitprobleme gefunden in der Bereitstellungsumgebung, wiederum basierend auf Beobachtbarkeitsdaten. Das spezifische Ergebnis, für das ich die sofortige Reaktion getestet habe, struggle eine Anomalie, die bei der Leistung eines bestimmten Endpunkts gefunden wurde. Es scheint, dass die Antworten manchmal waren ÄUSSERST Langsam, ~ 70x langsamer als der Median. Es struggle hilfreich, diesen Informationen zum LLM zu bereitstellen, aber letztendlich nicht mehr als einfache Wiederholungen der bereitgestellten Daten erreicht.

Als Referenz finden Sie hier die erhaltene Antwort sowie die Ausgabe des Agenten:

{
      "Title": "Efficiency Anomaly",
      "Class": "Efficiency",
      "P50":
      {
          "Worth": 12.33,
          "Unit": "ms",
          "Uncooked": 12331700.0
      },
      "P95":
      {
          "Worth": 909.62,
          "Unit": "ms",
          "Uncooked": 909625000.0
      },
      "SlowerByPercentage": 7376.314701136097,

      "SpanInfo":
      {
          ....
      },
      
      #extra knowledge  
      ....

        
}

Die API -Antwort oder die Artwork und Weise, wie die Informationen vom Agenten an den Benutzer vermittelt wurden, ist nichts falsch. Das einzige Downside ist, dass viel Kontext und Ideen fehlen, die die Fähigkeit des Agenten nutzen könnten, dieses Gespräch voranzutreiben. Mit anderen Worten, dies ist eine traditionelle API -Anfrage/Antwort -Interaktion, aber Agenten durch Argumentation sind so viel mehr in der Lage. Lassen Sie uns sehen, was passiert, wenn wir unsere API ändern, um zusätzlichen Zustand und Vorschläge zu vermitteln, um das Gespräch voranzutreiben:

{

  "_recommendation": 
      "This asset's P95 (slowest 5%) length is disproportionally gradual 
       in comparison with the median to an extreme diploma
       Listed here are some recommended investigative subsequent steps to get to the 
       root trigger or right the difficulty: 
       1. The problem contains instance traces for each the P95 and median
          length, get each traces and examine them discover out which asset 
          or property are those which might be abnormally gradual generally
       2. Verify the efficiency graphs for this asset P95 and see if there 
          has been a change lately, in that case test for pull requests 
          merged round that point which may be relevan tot his space 
       3. Verify for fruther clues within the gradual traces, for instance perhaps 
          ALL spans of the identical sort are gradual at the moment interval indicating
          a scientific subject"

    "Title": "Efficiency Anomaly",
    "Class": "Efficiency",
    "P50":
    {
        ...
    },
      #extra knowledge

Alles, was wir getan haben, ist, dem KI -Modell ein wenig mehr zu geben, um weiterzumachen. Anstatt einfach das Ergebnis zurückzugeben, können wir das Modell mit Ideen zur Verwendung der damit bereitgestellten Informationen füttern. Sicher genug werden diese Vorschläge sofort verwendet. Dieses Mal untersucht der Agent das Downside weiterhin, indem er andere Instruments aufruft, um das Verhalten zu inspizieren, die Spuren zu vergleichen und die Problemlinie zu verstehen:

Mit den neuen Informationen freut sich der Agent, die Erkundung fortzusetzen, die Zeitleiste zu untersuchen und die Ergebnisse der verschiedenen Instruments zu synthetisieren, bis es neue Daten erbracht hat. Dies struggle in keiner Weise Teil des ursprünglichen Antwortumfangs:

Warten Sie … sollte nicht alle APIs so gestaltet werden?

Absolut! Ich glaube definitiv, dass dieser Ansatz Benutzern, Automatisierungsentwicklern und allen anderen zugute kommen könnte – auch wenn sie Gehirne für Argumentation anstelle von LLM -Modellen verwenden. Im Wesentlichen kann eine konversationsorientierte API den Kontext über den Bereich der Daten hinaus in den Bereich der Möglichkeiten erweitern. Eröffnen Sie mehr Explorationszweige für Agenten und Benutzer gleichermaßen und verbessert die Effektivität von APIs bei der Lösung des zugrunde liegenden Anwendungsfalls.

Es gibt definitiv mehr Raum für die Evolution. Zum Beispiel waren die Hinweise und Ideen, die der API in unserem Beispiel dem Kunden zur Verfügung gestellt wurden, statisch. Was wäre, wenn sie auch mit A-generiert wären? Es gibt viele verschiedene A2A -Modelle da draußen, aber irgendwann könnte es sich nur um ein Backend -System und ein Kunde handeln, das sich über das, was die Daten bedeutet und was getan werden könnte, um es besser zu verstehen. Wie für den Benutzer? Vergiss ihn, sprich mit seinem Agenten.

Verpassen Sie nie eine neue Ausgabe von Die Variableunser wöchentlicher Publication mit einer erstklassigen Auswahl an Picks der Redakteure, Deep Dives, Group Information und mehr.

Der Agentic-AI-Landschaft entwickelt sich weiterhin mit einer erstaunlichen Geschwindigkeit, und die Praktiker stellen es zunehmend schwierig, mehrere Agenten auf die Aufgabe zu halten, selbst wenn sie sich gegenseitig die Workflows des anderen kreuzen.

Um Ihnen zu helfen, das Chaos zu minimieren und eine Harmonie zwischen den Agenten zu erhalten, haben wir eine herausragende Reihe von Artikeln zusammengestellt, in denen zwei kürzlich gestartete Instruments untersucht werden: Googles Agent2Agent-Protokoll und Umarmung von Face’s Smolagents Framework. Lesen Sie weiter, um zu erfahren, wie Sie sie in Ihren eigenen neuesten Projekten nutzen können.

---

Innerhalb von Googles Agent2Agent (A2A) -Protokoll: Lehren von KI -Agenten, miteinander zu sprechen

Wenn Sie Ihre ersten Schritte mit KI -Agenten unternehmen, verpassen Sie nicht Hailey Quach‚S zugängliche Einführung in das A2A-Protokoll: Es ist „wichtig, weil es verspricht, AI-Agenten aus ihren Silos zu brechen und sie eher wie ein intestine koordiniertes Staff als isolierte Genies zusammenarbeiten zu lassen.“

Kommunikation mit Multi-Agent mit dem A2A Python SDK

Bereit, mit A2A zu basteln? Deborah Mesquita Erstellt ein Spielzeugbeispiel, um Ihnen zu helfen, die inneren Arbeiten des Protokolls zu verstehen.

Von Daten zu Geschichten: Code -Agenten für KPI -Erzählungen

Für einen anderen Ansatz bei der Multi-Agent-Orchestrierung, Mariya Mansurova führt uns durch einen Smolagents-Workflow.

---

Die Should-Learn-Geschichten dieser Woche

Nachholen Sie die Artikel, über die unsere Group in den letzten Tagen summt hat. Hier ist eine Zusammenfassung der Trendgeschichten dieser Woche:

So entwerfen Sie meinen ersten KI -Agenten von Fabiana Clemente

Aufbau eines modernen Armaturenbretts mit Python und Gradio von, von Thomas Reid

Wie ich meinen Workflow für maschinelles Lernen mit nur 10 Zeilen von Python automatisiert habe, von Himanshu Sharma

---

Andere empfohlene Lesevorgänge

Entdecken Sie einige unserer erstklassigen Artikel zu anderen Themen, von LLM-Agenten-Benchmarks bis hin zu bewährten Praxen.

• Gaia: Der LLM -Agent -Benchmark alle reden über, von, von, von Shuai Guo

• Bayesianische Optimierung für die Hyperparameter -Abstimmung von Deep -Studying -Modellen von, von Kuriko Iwai

• Die Reise von Jupyter zum Programmierer: ein Schnellstarthandbuch, von Lucy Dickinson

---

Treffen Sie unsere neuen Autoren

Jede Woche sind wir begeistert, eine neue Kohorte von Datenwissenschaft, maschinellem Lernen und KI -Experten willkommen zu heißen. Verpassen Sie nicht die Arbeit einiger unserer neuesten Mitwirkenden:

• Maciej Adamiak Kombiniert eine Leidenschaft für Geospatial -Daten und tiefes Lernen mit Forschung an der Universität von łódź.

• Sylvain Kalache ist der Leiter von AI Labs in Rootly und verfügt über einen interdisziplinären Hintergrund, der Kommunikation und Bildung umfasst.

• DOSTER ESH Erfolgt sein Schreiben mit tiefem Fachwissen in Bezug auf Datenwissenschaft, Wirtschaft und Risikobewertung unter anderem.

Wir lieben es, Artikel von neuen Autoren zu veröffentlichen. Wenn Sie additionally kürzlich ein interessantes Projektwechsel, Tutorial oder theoretische Reflexion über eines unserer Kernthemen geschrieben haben, warum nicht Teile es mit uns?

---

Abonnieren Sie unseren Publication

(LLMs) verbessert sich in der Effizienz und können jetzt verschiedene Datenformate verstehen und Möglichkeiten für unzählige Anwendungen in verschiedenen Bereichen bieten. Anfangs konnten LLMs von Natur aus nur Textual content verarbeiten. Das Bildverständnisfunktion wurde durch Kopplung eines LLM mit einem anderen Bildcodierungsmodell integriert. Jedoch, gpt-4o wurde sowohl auf Textual content als auch auf Bilder trainiert und ist das erste echte multimodale LLM, das sowohl Textual content als auch Bilder verstehen kann. Andere Modalitäten wie Audio werden durch andere KI -Modelle, z. B. die Flüstermodelle von OpenAI, in moderne LLMs integriert.

LLMs werden jetzt mehr als Informationsprozessoren verwendet, bei denen Daten in verschiedenen Formaten verarbeitet werden können. Die Integration mehrerer Modalitäten in LLMs öffnet Bereiche zahlreicher Anwendungen in der Bildung, Geschäftund andere Sektoren. Eine solche Anwendung ist die Verarbeitung von Bildungsvideos, Dokumentarfilmen, Webinaren, Präsentationen, Geschäftstreffen, Vorträgen und anderen Inhalten unter Verwendung von LLMs und der Interaktion mit diesen Inhalten natürlicher. Die Audio -Modalität in diesen Movies enthält umfangreiche Informationen, die in einer Reihe von Anwendungen verwendet werden könnten. In Bildungsumgebungen kann es für personalisiertes Lernen verwendet werden, die Zugänglichkeit von Schülern mit besonderen Bedürfnissen, die Erstellung von Studienhilfen, die Unterstützung des Fernunterrichts, die Präsenz eines Lehrers, um Inhalte zu verstehen, und die Bewertung des Wissens der Schüler über ein Thema zu verbessern. In den Geschäftsumgebungen kann es verwendet werden, um neue Mitarbeiter mit Onboarding -Movies, das Extrahieren und Generieren von Kenntnissen aus Aufzeichnungsbesprechungen und Präsentationen, maßgeschneiderten Lernmaterialien aus Produktdemonstrationsvideos und Extrahieren von Erkenntnissen aus aufgezeichneten Branchenkonferenzen verwendet werden, ohne Stunden der Movies anzusehen, um nur einige zu nennen.

In diesem Artikel wird die Entwicklung einer Anwendung zur Interaktion mit Movies auf natürliche Weise erörtert und Lerninhalte von ihnen erstellt. Die Anwendung hat die folgenden Funktionen:

• Es führt ein Eingangsvideo entweder über eine URL oder aus einem lokalen Pfad und extrahiert Audio aus dem Video
• Transkribiert das Audio mithilfe des hochmodernen Modells von OpenAI gpt-4o-transcribeAnwesend Dies hat eine verbesserte Leistung der Wortfehlerrate (WER) gegenüber vorhandenen Flüstermodellen über mehrere etablierte Benchmarks gezeigt
• Erstellt einen Vektorspeicher des Transkripts und entwickelt eine Abruf -Increase -Era (RAG), um ein Gespräch mit dem Video -Transkript zu führen
• Beantworten Sie die Fragen der Benutzer in Textual content und Sprache mit verschiedenen Stimmen, die aus der Benutzeroberfläche der Anwendung ausgewählt werden können.
• Erstellt Lerninhalte wie:
  • Hierarchische Darstellung des Videoinhalts, um den Benutzern schnelle Einblicke in die Hauptkonzepte und unterstützenden Particulars zu geben
  • Generieren Sie Quiz, um das passive Video -Ansehen in aktives Lernen zu verwandeln, indem Sie Benutzer dazu fordern, Informationen zu erinnern und im Video präsentiertes Informationen anzuwenden.
  • Generiert Flashkarten aus den Videoinhalten, die aktiven Rückruf- und Abstands -Wiederholungslernentechniken unterstützen

Der gesamte Workflow der Anwendung ist in der folgenden Abbildung dargestellt.

Die gesamte Codebasis sowie detaillierte Anweisungen für die Set up und Verwendung finden Sie auf Github.

Hier ist die Struktur des Github -Repositorys. Die Hauptanwendung von Streamlit implementiert die GUI -Schnittstelle und ruft mehrere andere Funktionen aus anderen Funktionen und Helfermodulen auf ((.py Dateien).

Darüber hinaus können Sie die Codebasis visualisieren, indem Sie das öffnen.Codebasis -Visualisierung”HTML -Datei in einem Browser, der die Strukturen jedes Moduls beschreibt.

Lassen Sie uns die schrittweise Entwicklung dieser Anwendung eintauchen. Ich werde nicht den gesamten Code diskutieren, sondern nur seinen Hauptteil. Der gesamte Code im Github -Repository wird angemessen kommentiert.

Videoeingabe und Verarbeitung

Videoeingabe- und Verarbeitungslogik werden in implementiert transcriber.py. Wenn die Anwendung lädt, wird überprüft, ob FFMPEG vorhanden ist (verify_ffmpeg) im Stammverzeichnis der Anwendung. FFMPEG ist zum Herunterladen eines Movies (wenn die Eingabe eine URL ist) und das Extrahieren von Audio aus dem Video erforderlich, mit dem dann ein Transkript erstellt wird.

def verify_ffmpeg():
    """Confirm that FFmpeg is offered and print its location."""
    # Add FFmpeg to PATH
    os.environ('PATH') = FFMPEG_LOCATION + os.pathsep + os.environ('PATH')
    # Examine if FFmpeg binaries exist
    ffmpeg_path = os.path.be a part of(FFMPEG_LOCATION, 'ffmpeg.exe')
    ffprobe_path = os.path.be a part of(FFMPEG_LOCATION, 'ffprobe.exe')
    if not os.path.exists(ffmpeg_path):
        increase FileNotFoundError(f"FFmpeg executable not discovered at: {ffmpeg_path}")
    if not os.path.exists(ffprobe_path):
        increase FileNotFoundError(f"FFprobe executable not discovered at: {ffprobe_path}")
    print(f"FFmpeg discovered at: {ffmpeg_path}")
    print(f"FFprobe discovered at: {ffprobe_path}")
    # Attempt to execute FFmpeg to ensure it really works
    attempt:
        # Add shell=True for Home windows and seize errors correctly
        end result = subprocess.run((ffmpeg_path, '-version'), 
                               stdout=subprocess.PIPE, 
                               stderr=subprocess.PIPE,
                               shell=True,  # This will help with permission points on Home windows
                               test=False)
        if end result.returncode == 0:
            print(f"FFmpeg model: {end result.stdout.decode().splitlines()(0)}")
        else:
            error_msg = end result.stderr.decode()
            print(f"FFmpeg error: {error_msg}")
            # Examine for particular permission errors
            if "Entry is denied" in error_msg:
                print("Permission error detected. Making an attempt different strategy...")
                # Strive an alternate strategy - simply test file existence with out execution
                if os.path.exists(ffmpeg_path) and os.path.exists(ffprobe_path):
                    print("FFmpeg recordsdata exist however execution take a look at failed as a result of permissions.")
                    print("WARNING: The app might fail when making an attempt to course of movies.")
                    # Return paths anyway and hope for the perfect when truly used
                    return ffmpeg_path, ffprobe_path
                
            increase RuntimeError(f"FFmpeg execution failed: {error_msg}")
    besides Exception as e:
        print(f"Error checking FFmpeg: {e}")
        # Fallback choice if verification fails however recordsdata exist
        if os.path.exists(ffmpeg_path) and os.path.exists(ffprobe_path):
            print("WARNING: FFmpeg recordsdata exist however verification failed.")
            print("Trying to proceed anyway, however video processing might fail.")
            return ffmpeg_path, ffprobe_path 
        increase
    return ffmpeg_path, ffprobe_path

Die Videoeingabe erfolgt in Kind einer URL (z. B. YouTube -URL) oder einem lokalen Dateipfad. Der process_video Die Funktion bestimmt den Eingangstyp und leitet ihn entsprechend weiter. Wenn die Eingabe eine URL ist, funktioniert die Helfer get_video_info Und get_video_id Video -Metadaten (Titel, Beschreibung, Dauer) extrahieren, ohne sie herunterzuladen yt_dlp Paket.

#Operate to find out the enter kind and route it appropriately
def process_video(youtube_url, output_dir, api_key, mannequin="gpt-4o-transcribe"):
    """
    Course of a YouTube video to generate a transcript
    Wrapper perform that mixes obtain and transcription
    Args:
        youtube_url: URL of the YouTube video
        output_dir: Listing to save lots of the output
        api_key: OpenAI API key
        mannequin: The mannequin to make use of for transcription (default: gpt-4o-transcribe)
    Returns:
        dict: Dictionary containing transcript and file paths
    """
    # First obtain the audio
    print("Downloading video...")
    audio_path = process_video_download(youtube_url, output_dir)
    
    print("Transcribing video...")
    # Then transcribe the audio
    transcript, transcript_path = process_video_transcribe(audio_path, output_dir, api_key, mannequin=mannequin)
    
    # Return the mixed outcomes
    return {
        'transcript': transcript,
        'transcript_path': transcript_path,
        'audio_path': audio_path
    }

def get_video_info(youtube_url):
    """Get video data with out downloading."""
    # Examine native cache first
    world _video_info_cache
    if youtube_url in _video_info_cache:
        return _video_info_cache(youtube_url)
        
    # Extract information if not cached
    with yt_dlp.YoutubeDL() as ydl:
        information = ydl.extract_info(youtube_url, obtain=False)
        # Cache the end result
        _video_info_cache(youtube_url) = information
        # Additionally cache the video ID individually
        _video_id_cache(youtube_url) = information.get('id', 'video')
        return information

def get_video_id(youtube_url):
    """Get simply the video ID with out re-extracting if already recognized."""
    world _video_id_cache
    if youtube_url in _video_id_cache:
        return _video_id_cache(youtube_url)
    
    # If not in cache, extract from URL instantly if potential
    if "v=" in youtube_url:
        video_id = youtube_url.break up("v=")(1).break up("&")(0)
        _video_id_cache(youtube_url) = video_id
        return video_id
    elif "youtu.be/" in youtube_url:
        video_id = youtube_url.break up("youtu.be/")(1).break up("?")(0)
        _video_id_cache(youtube_url) = video_id
        return video_id
    
    # If we will not extract instantly, fall again to full information extraction
    information = get_video_info(youtube_url)
    video_id = information.get('id', 'video')
    return video_id

Nachdem die Videoeingabe angegeben wurde, ist der Code in app.py Überprüft, ob ein Transkript für das Eingabevideo bereits vorhanden ist (im Fall von URL -Eingabe). Dies erfolgt durch die Aufrufen der folgenden zwei Helferfunktionen von transcriber.py.

def get_transcript_path(youtube_url, output_dir):
    """Get the anticipated transcript path for a given YouTube URL."""
    # Get video ID with caching
    video_id = get_video_id(youtube_url)
    # Return anticipated transcript path
    return os.path.be a part of(output_dir, f"{video_id}_transcript.txt")

def transcript_exists(youtube_url, output_dir):
    """Examine if a transcript already exists for this video."""
    transcript_path = get_transcript_path(youtube_url, output_dir)
    return os.path.exists(transcript_path)

Wenn transcript_exists Gibt den Pfad eines vorhandenen Transkripts zurück. Der nächste Schritt besteht darin, den Vektorspeicher für den Lappen zu erstellen. Wenn kein vorhandenes Transkript gefunden wird, besteht der nächste Schritt darin, Audio aus der URL herunterzuladen und in ein Commonplace -Audio -Format umzuwandeln. Die Funktion process_video_download Laden Sie Audio aus der URL mit der FFMPEG -Bibliothek herunter und konvertiert sie in .mp3 Format. Wenn die Eingabe eine lokale Videodatei ist, ist app.py erreibt es, um es in die Umwandlung zu .mp3 Datei.

def process_video_download(youtube_url, output_dir):
    """
    Obtain audio from a YouTube video
    Args:
        youtube_url: URL of the YouTube video
        output_dir: Listing to save lots of the output
        
    Returns:
        str: Path to the downloaded audio file
    """
    # Create output listing if it does not exist
    os.makedirs(output_dir, exist_ok=True)
    
    # Extract video ID from URL
    video_id = None
    if "v=" in youtube_url:
        video_id = youtube_url.break up("v=")(1).break up("&")(0)
    elif "youtu.be/" in youtube_url:
        video_id = youtube_url.break up("youtu.be/")(1).break up("?")(0)
    else:
        increase ValueError("Couldn't extract video ID from URL")
    # Set output paths
    audio_path = os.path.be a part of(output_dir, f"{video_id}.mp3")
    
    # Configure yt-dlp choices
    ydl_opts = {
        'format': 'bestaudio/greatest',
        'postprocessors': ({
            'key': 'FFmpegExtractAudio',
            'preferredcodec': 'mp3',
            'preferredquality': '192',
        }),
        'outtmpl': os.path.be a part of(output_dir, f"{video_id}"),
        'quiet': True
    }
    
    # Obtain audio
    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
        ydl.obtain((youtube_url))
    
    # Confirm audio file exists
    if not os.path.exists(audio_path):
        # Strive with an extension that yt-dlp may need used
        potential_paths = (
            os.path.be a part of(output_dir, f"{video_id}.mp3"),
            os.path.be a part of(output_dir, f"{video_id}.m4a"),
            os.path.be a part of(output_dir, f"{video_id}.webm")
        )
        
        for path in potential_paths:
            if os.path.exists(path):
                # Convert to mp3 if it is not already
                if not path.endswith('.mp3'):
                    ffmpeg_path = verify_ffmpeg()(0)
                    output_mp3 = os.path.be a part of(output_dir, f"{video_id}.mp3")
                    subprocess.run((
                        ffmpeg_path, '-i', path, '-c:a', 'libmp3lame', 
                        '-q:a', '2', output_mp3, '-y'
                    ), test=True, capture_output=True)
                    os.take away(path)  # Take away the unique file
                    audio_path = output_mp3
                else:
                    audio_path = path
                break
        else:
            increase FileNotFoundError(f"Couldn't discover downloaded audio file for video {video_id}")
    return audio_path

Audio -Transkription mit OpenAIs gpt-4o-transcribe Modell

Nach dem Extrahieren von Audio und der Konvertierung in ein Commonplace -Audio -Format besteht der nächste Schritt darin, das Audio in Textformat zu transkribieren. Zu diesem Zweck habe ich die neu gestartete Openai verwendet gpt-4o-transcribe Sprach-zu-Textual content-Modell zugänglich über Rede-to-Textual content-API. Dieses Modell hat OpenAIs übertroffen Flüstern Modelle sowohl in Bezug auf die Transkriptionsgenauigkeit als auch in Bezug auf eine robuste Sprachabdeckung.

Die Funktion process_video_transcribe In transcriber.py empfängt die konvertierte Audiodatei und Schnittstellen mit gpt-4o-transcribe Modell mit OpenAs Rede-to-Textual content-API. Der gpt-4o-transcribe Das Modell verfügt derzeit über ein Audiodateilimit von 25 MB und 1500 Dauer. Um diese Einschränkung zu überwinden, habe ich die längeren Dateien in mehrere Stücke aufgeteilt und diese Brocken getrennt transkribieren. Der process_video_transcribe Die Funktion prüft, ob die Eingabedatei die Größen- und/oder Dauergrenze überschreitet. Wenn der eine der Schwellenwert überschritten wird, ruft sie auf split_and_transcribe Funktion, die zuerst die Anzahl der benötigten Stücke berechnet, die sowohl auf Größe als auch auf der Dauer benötigt werden, und das Most dieser beiden als endgültige Anzahl von Stücken für die Transkription nimmt. Anschließend findet es die Begin- und Endzeiten für jeden Stück und extrahiert diese Stücke aus der Audiodatei. Anschließend transkribiert es jeden Chunk mithilfe gpt-4o-transcribe Modell mit OpenAs Sprach-zu-Textual content-API und kombiniert dann Transkripte aller Teile, um das endgültige Transkript zu generieren.

def process_video_transcribe(audio_path, output_dir, api_key, progress_callback=None, mannequin="gpt-4o-transcribe"):
    """
    Transcribe an audio file utilizing OpenAI API, with automated chunking for giant recordsdata
    At all times makes use of the chosen mannequin, with no fallback
    
    Args:
        audio_path: Path to the audio file
        output_dir: Listing to save lots of the transcript
        api_key: OpenAI API key
        progress_callback: Operate to name with progress updates (0-100)
        mannequin: The mannequin to make use of for transcription (default: gpt-4o-transcribe)
        
    Returns:
        tuple: (transcript textual content, transcript path)
    """
    # Extract video ID from audio path
    video_id = os.path.basename(audio_path).break up('.')(0)
    transcript_path = os.path.be a part of(output_dir, f"{video_id}_transcript.txt")
    
    # Setup OpenAI consumer
    consumer = OpenAI(api_key=api_key)
    
    # Replace progress
    if progress_callback:
        progress_callback(10)
    
    # Get file dimension in MB
    file_size_mb = os.path.getsize(audio_path) / (1024 * 1024)
    
    # Common chunking thresholds - apply to each fashions
    max_size_mb = 25  # 25MB chunk dimension for each fashions
    max_duration_seconds = 1500  # 1500 seconds chunk period for each fashions
    
    # Load the audio file to get its period
    attempt:
        audio = AudioSegment.from_file(audio_path)
        duration_seconds = len(audio) / 1000  # pydub makes use of milliseconds
    besides Exception as e:
        print(f"Error loading audio to test period: {e}")
        audio = None
        duration_seconds = 0
    
    # Decide if chunking is required
    needs_chunking = False
    chunking_reason = ()
    
    if file_size_mb > max_size_mb:
        needs_chunking = True
        chunking_reason.append(f"dimension ({file_size_mb:.2f}MB exceeds {max_size_mb}MB)")
    
    if duration_seconds > max_duration_seconds:
        needs_chunking = True
        chunking_reason.append(f"period ({duration_seconds:.2f}s exceeds {max_duration_seconds}s)")
    
    # Log the choice
    if needs_chunking:
        reason_str = " and ".be a part of(chunking_reason)
        print(f"Audio wants chunking as a result of {reason_str}. Utilizing {mannequin} for transcription.")
    else:
        print(f"Audio file is inside limits. Utilizing {mannequin} for direct transcription.")
    
    # Examine if file wants chunking
    if needs_chunking:
        if progress_callback:
            progress_callback(15)
        
        # Break up the audio file into chunks and transcribe every chunk utilizing the chosen mannequin solely
        full_transcript = split_and_transcribe(
            audio_path, consumer, mannequin, progress_callback, 
            max_size_mb, max_duration_seconds, audio
        )
    else:
        # File is sufficiently small, transcribe instantly with the chosen mannequin
        with open(audio_path, "rb") as audio_file:
            if progress_callback:
                progress_callback(30)
                
            transcript_response = consumer.audio.transcriptions.create(
                mannequin=mannequin, 
                file=audio_file
            )
            
            if progress_callback:
                progress_callback(80)
            
            full_transcript = transcript_response.textual content
    
    # Save transcript to file
    with open(transcript_path, "w", encoding="utf-8") as f:
        f.write(full_transcript)
    
    # Replace progress
    if progress_callback:
        progress_callback(100)
    
    return full_transcript, transcript_path

def split_and_transcribe(audio_path, consumer, mannequin, progress_callback=None, 
                         max_size_mb=25, max_duration_seconds=1500, audio=None):
    """
    Break up an audio file into chunks and transcribe every chunk 
    
    Args:
        audio_path: Path to the audio file
        consumer: OpenAI consumer
        mannequin: Mannequin to make use of for transcription (won't fall again to different fashions)
        progress_callback: Operate to name with progress updates
        max_size_mb: Most file dimension in MB
        max_duration_seconds: Most period in seconds
        audio: Pre-loaded AudioSegment (elective)
        
    Returns:
        str: Mixed transcript from all chunks
    """
    # Load the audio file if not offered
    if audio is None:
        audio = AudioSegment.from_file(audio_path)
    
    # Get audio period in seconds
    duration_seconds = len(audio) / 1000
    
    # Calculate the variety of chunks wanted based mostly on each dimension and period
    file_size_mb = os.path.getsize(audio_path) / (1024 * 1024)
    
    chunks_by_size = math.ceil(file_size_mb / (max_size_mb * 0.9))  # Use 90% of max to be protected
    chunks_by_duration = math.ceil(duration_seconds / (max_duration_seconds * 0.95))  # Use 95% of max to be protected
    num_chunks = max(chunks_by_size, chunks_by_duration)
    
    print(f"Splitting audio into {num_chunks} chunks based mostly on dimension ({chunks_by_size}) and period ({chunks_by_duration})")
    
    # Calculate chunk period in milliseconds
    chunk_length_ms = len(audio) // num_chunks
    
    # Create temp listing for chunks if it does not exist
    temp_dir = os.path.be a part of(os.path.dirname(audio_path), "temp_chunks")
    os.makedirs(temp_dir, exist_ok=True)
    
    # Break up the audio into chunks and transcribe every chunk
    transcripts = ()
    
    for i in vary(num_chunks):
        if progress_callback:
            # Replace progress: 20% for splitting, 60% for transcribing
            progress_percent = 20 + int((i / num_chunks) * 60)
            progress_callback(progress_percent)
        
        # Calculate begin and finish instances for this chunk
        start_ms = i * chunk_length_ms
        end_ms = min((i + 1) * chunk_length_ms, len(audio))
        
        # Extract the chunk
        chunk = audio(start_ms:end_ms)
        
        # Save the chunk to a short lived file
        chunk_path = os.path.be a part of(temp_dir, f"chunk_{i}.mp3")
        chunk.export(chunk_path, format="mp3")
        
        # Log chunk data
        chunk_size_mb = os.path.getsize(chunk_path) / (1024 * 1024)
        chunk_duration = len(chunk) / 1000
        print(f"Chunk {i+1}/{num_chunks}: {chunk_size_mb:.2f}MB, {chunk_duration:.2f}s")
        
        # Transcribe the chunk 
        attempt:
            with open(chunk_path, "rb") as chunk_file:
                transcript_response = consumer.audio.transcriptions.create(
                    mannequin=mannequin,
                    file=chunk_file
                )
                
                # Add to our checklist of transcripts
                transcripts.append(transcript_response.textual content)
        besides Exception as e:
            print(f"Error transcribing chunk {i+1} with {mannequin}: {e}")
            # Add a placeholder for the failed chunk
            transcripts.append(f"(Transcription failed for phase {i+1})")
        
        # Clear up the momentary chunk file
        os.take away(chunk_path)
    
    # Clear up the momentary listing
    attempt:
        os.rmdir(temp_dir)
    besides:
        print(f"Be aware: Couldn't take away momentary listing {temp_dir}")
    
    # Mix all transcripts with correct spacing
    full_transcript = " ".be a part of(transcripts)
    
    return full_transcript

Der folgende Screenshot der Streamlit -App zeigt den Videoverarbeitung und den Transkriptieren des Workflows für einen meiner Webinare. “Integration von LLMs in das Geschäft„ Erhältlich auf meinem YouTube -Kanal.

Abrufenvergrößerungsgeneration (RAG) für interaktive Gespräche

Nach dem Generieren des Video-Transkripts entwickelt die Anwendung einen Lappen, um sowohl Textual content- als auch sprachbasierte Interaktionen zu erleichtern. Die Konversations -Intelligenz wird durch implementiert VideoRAG Klasse in rag_system.py die initialisiert die Größe und Überlappung, Openai -Einbettungen, ChatOpenAI Instanz, um Antworten mit zu generieren gpt-4o Modell und ConversationBufferMemory Chat -Historie für kontextbezogene Kontinuität aufrechtzuerhalten.

Der create_vector_store Die Methode spaltet die Dokumente in Stücke und erstellt einen Vektorspeicher mithilfe der FAISS -Vektor -Datenbank. Der handle_question_submission Methode verarbeitet Textfragen und findet jede neue Frage und ihre Antwort auf den Gesprächsgeschichte an. Die Funktion „Handle_Speech_input“ implementiert die vollständige Pipeline mit Voice-to-Textual content-zu-Voice. Es wird zunächst die Frage Audio aufgezeichnet, die Frage transkribiert, die Abfrage durch das Lappensystem verarbeitet und die Sprache für die Antwort synthetisiert.

class VideoRAG:
    def __init__(self, api_key=None, chunk_size=1000, chunk_overlap=200):
        """Initialize the RAG system with OpenAI API key."""
        # Use offered API key or attempt to get from surroundings
        self.api_key = api_key if api_key else st.secrets and techniques("OPENAI_API_KEY")
        if not self.api_key:
            increase ValueError("OpenAI API secret's required both as parameter or surroundings variable")
            
        self.embeddings = OpenAIEmbeddings(openai_api_key=self.api_key)
        self.llm = ChatOpenAI(
            openai_api_key=self.api_key,
            mannequin="gpt-4o",
            temperature=0
        )
        self.chunk_size = chunk_size
        self.chunk_overlap = chunk_overlap
        self.vector_store = None
        self.chain = None
        self.reminiscence = ConversationBufferMemory(
            memory_key="chat_history",
            return_messages=True
        )
    
    def create_vector_store(self, transcript):
        """Create a vector retailer from the transcript."""
        # Break up the textual content into chunks
        text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=self.chunk_size,
            chunk_overlap=self.chunk_overlap,
            separators=("nn", "n", " ", "")
        )
        chunks = text_splitter.split_text(transcript)
        
        # Create vector retailer
        self.vector_store = FAISS.from_texts(chunks, self.embeddings)
        
        # Create immediate template for the RAG system
        system_template = """You're a specialised AI assistant that solutions questions on a selected video. 
        
        You might have entry to snippets from the video transcript, and your position is to supply correct data ONLY based mostly on these snippets.
        
        Pointers:
        1. Solely reply questions based mostly on the knowledge offered within the context from the video transcript, in any other case say that "I do not know. The video does not cowl that data."
        2. The query might ask you to summarize the video or inform what the video is about. In that case, current a abstract of the context. 
        3. Do not make up data or use information from outdoors the offered context
        4. Preserve your solutions concise and instantly associated to the query
        5. If requested about your capabilities or id, clarify that you simply're an AI assistant that makes a speciality of answering questions on this particular video
        
        Context from the video transcript:
        {context}
        
        Chat Historical past:
        {chat_history}
        """
        user_template = "{query}"
        
        # Create the messages for the chat immediate
        messages = (
            SystemMessagePromptTemplate.from_template(system_template),
            HumanMessagePromptTemplate.from_template(user_template)
        )
        
        # Create the chat immediate
        qa_prompt = ChatPromptTemplate.from_messages(messages)
        
        # Initialize the RAG chain with the customized immediate
        self.chain = ConversationalRetrievalChain.from_llm(
            llm=self.llm,
            retriever=self.vector_store.as_retriever(
                search_kwargs={"okay": 5}
            ),
            reminiscence=self.reminiscence,
            combine_docs_chain_kwargs={"immediate": qa_prompt},
            verbose=True
        )
        
        return len(chunks)
    
    def set_chat_history(self, chat_history):
        """Set chat historical past from exterior session state."""
        if not self.reminiscence:
            return
            
        # Clear present reminiscence
        self.reminiscence.clear()
        
        # Convert commonplace chat historical past format to LangChain message format
        for message in chat_history:
            if message("position") == "consumer":
                self.reminiscence.chat_memory.add_user_message(message("content material"))
            elif message("position") == "assistant":
                self.reminiscence.chat_memory.add_ai_message(message("content material"))
    
    def ask(self, query, chat_history=None):
        """Ask a query to the RAG system."""
        if not self.chain:
            increase ValueError("Vector retailer not initialized. Name create_vector_store first.")
        
        # If chat historical past is offered, replace the reminiscence
        if chat_history:
            self.set_chat_history(chat_history)
        
        # Get response
        response = self.chain.invoke({"query": query})
        return response("reply")

Sehen Sie sich den folgenden Schnappschuss der Streamlit -App an und zeigen die interaktive Konversationsschnittstelle mit dem Video an.

Der folgende Snapshot zeigt eine Konversation mit dem Video mit Spracheingabe und Textual content+Sprachausgabe.

Characteristic -Generierung

Die Anwendung generiert drei Merkmale: hierarchische Zusammenfassung, Quiz und Karteikarten. Bitte beachten Sie ihre jeweiligen kommentierten Codes in der Github Repo.

Der SummaryGenerator Klasse in abstract.py Bietet eine strukturierte Inhaltsübersicht, indem eine hierarchische Darstellung der Videoinhalte erstellt wird, um den Benutzern schnelle Einblicke in die Hauptkonzepte und unterstützenden Particulars zu geben. Das System ruft wichtige Kontextsegmente aus dem Transkript mit RAG ab. Verwenden einer Eingabeaufforderung (siehe generate_summary), es erzeugt eine hierarchische Zusammenfassung mit drei Ebenen: Hauptpunkte, Unterpunkte und zusätzliche Particulars. Der create_summary_popup_html Die Methode transformiert die generierte Zusammenfassung mithilfe von CSS und JavaScript in eine interaktive visuelle Darstellung.

# abstract.py
class SummaryGenerator:
    def __init__(self):
        move
    
    def generate_summary(self, rag_system, api_key, mannequin="gpt-4o", temperature=0.2):
        """
        Generate a hierarchical bullet-point abstract from the video transcript
        
        Args:
            rag_system: The RAG system with vector retailer
            api_key: OpenAI API key
            mannequin: Mannequin to make use of for abstract technology
            temperature: Creativity degree (0.0-1.0)
            
        Returns:
            str: Hierarchical bullet-point abstract textual content
        """
        if not rag_system:
            st.error("Please transcribe the video first earlier than making a abstract!")
            return ""
        
        with st.spinner("Producing hierarchical abstract..."):
            # Create LLM for abstract technology
            summary_llm = ChatOpenAI(
                openai_api_key=api_key,
                mannequin=mannequin,
                temperature=temperature  # Decrease temperature for extra factual summaries
            )
            
            # Use the RAG system to get related context
            attempt:
                # Get broader context since we're summarizing the entire video
                relevant_docs = rag_system.vector_store.similarity_search(
                    "summarize the details of this video", okay=10
                )
                context = "nn".be a part of((doc.page_content for doc in relevant_docs))
                
                immediate = """Based mostly on the video transcript, create a hierarchical bullet-point abstract of the content material.
                Construction your abstract with precisely these ranges:
                
                • Details (use • or * in the beginning of the road for these top-level factors)
                  - Sub-points (use - in the beginning of the road for these second-level particulars)
                    * Further particulars (use areas adopted by * for third-level factors)
                
                For instance:
                • First important level
                  - Vital element concerning the first level
                  - One other essential element
                    * A selected instance
                    * One other particular instance
                • Second important level
                  - Element about second level
                
                Be in keeping with the precise formatting proven above. Every bullet degree should begin with the precise character proven (• or *, -, and areas+*).
                Create 3-5 details with 2-4 sub-points every, and add third-level particulars the place applicable.
                Give attention to an important data from the video.
                """
                
                # Use the LLM with context to generate the abstract
                messages = (
                    {"position": "system", "content material": f"You're given the next context from a video transcript:nn{context}nnUse this context to create a hierarchical abstract in keeping with the directions."},
                    {"position": "consumer", "content material": immediate}
                )
                
                response = summary_llm.invoke(messages)
                return response.content material
            besides Exception as e:
                # Fallback to the common RAG system if there's an error
                st.warning(f"Utilizing commonplace abstract technology as a result of error: {str(e)}")
                return rag_system.ask(immediate)
    
    def create_summary_popup_html(self, summary_content):
        """
        Create HTML for the abstract popup with correctly formatted hierarchical bullets
        
        Args:
            summary_content: Uncooked abstract textual content with markdown bullet formatting
            
        Returns:
            str: HTML for the popup with correctly formatted bullets
        """
        # As an alternative of counting on markdown conversion, let's manually parse and format the bullet factors
        strains = summary_content.strip().break up('n')
        formatted_html = ()
        
        in_list = False
        list_level = 0
        
        for line in strains:
            line = line.strip()
            
            # Skip empty strains
            if not line:
                proceed
                
            # Detect if it is a markdown header
            if line.startswith('# '):
                if in_list:
                    # Shut any open lists
                    for _ in vary(list_level):
                        formatted_html.append('</ul>')
                    in_list = False
                    list_level = 0
                formatted_html.append(f'<h1>{line(2:)}</h1>')
                proceed
                
            # Examine line for bullet level markers
            if line.startswith('• ') or line.startswith('* '):
                # Prime degree bullet
                content material = line(2:).strip()
                
                if not in_list:
                    # Begin a brand new checklist
                    formatted_html.append('<ul class="top-level">')
                    in_list = True
                    list_level = 1
                elif list_level > 1:
                    # Shut nested lists to get again to high degree
                    for _ in vary(list_level - 1):
                        formatted_html.append('</ul></li>')
                    list_level = 1
                else:
                    # Shut earlier checklist merchandise if wanted
                    if formatted_html and never formatted_html(-1).endswith('</ul></li>') and in_list:
                        formatted_html.append('</li>')
                        
                formatted_html.append(f'<li class="top-level-item">{content material}')
                
            elif line.startswith('- '):
                # Second degree bullet
                content material = line(2:).strip()
                
                if not in_list:
                    # Begin new lists
                    formatted_html.append('<ul class="top-level"><li class="top-level-item">Second degree objects')
                    formatted_html.append('<ul class="second-level">')
                    in_list = True
                    list_level = 2
                elif list_level == 1:
                    # Add a nested checklist
                    formatted_html.append('<ul class="second-level">')
                    list_level = 2
                elif list_level > 2:
                    # Shut deeper nested lists to get to second degree
                    for _ in vary(list_level - 2):
                        formatted_html.append('</ul></li>')
                    list_level = 2
                else:
                    # Shut earlier checklist merchandise if wanted
                    if formatted_html and never formatted_html(-1).endswith('</ul></li>') and list_level == 2:
                        formatted_html.append('</li>')
                        
                formatted_html.append(f'<li class="second-level-item">{content material}')
                
            elif line.startswith('  * ') or line.startswith('    * '):
                # Third degree bullet
                content material = line.strip()(2:).strip()
                
                if not in_list:
                    # Begin new lists (all ranges)
                    formatted_html.append('<ul class="top-level"><li class="top-level-item">Prime degree')
                    formatted_html.append('<ul class="second-level"><li class="second-level-item">Second degree')
                    formatted_html.append('<ul class="third-level">')
                    in_list = True
                    list_level = 3
                elif list_level == 2:
                    # Add a nested checklist
                    formatted_html.append('<ul class="third-level">')
                    list_level = 3
                elif list_level < 3:
                    # We missed a degree, alter
                    formatted_html.append('<li>Lacking degree</li>')
                    formatted_html.append('<ul class="third-level">')
                    list_level = 3
                else:
                    # Shut earlier checklist merchandise if wanted
                    if formatted_html and never formatted_html(-1).endswith('</ul></li>') and list_level == 3:
                        formatted_html.append('</li>')
                        
                formatted_html.append(f'<li class="third-level-item">{content material}')
            else:
                # Common paragraph
                if in_list:
                    # Shut any open lists
                    for _ in vary(list_level):
                        formatted_html.append('</ul>')
                        if list_level > 1:
                            formatted_html.append('</li>')
                    in_list = False
                    list_level = 0
                formatted_html.append(f'<p>{line}</p>')
        
        # Shut any open lists
        if in_list:
            # Shut ultimate merchandise
            formatted_html.append('</li>')
            # Shut any open lists
            for _ in vary(list_level):
                if list_level > 1:
                    formatted_html.append('</ul></li>')
                else:
                    formatted_html.append('</ul>')
        
        summary_html = 'n'.be a part of(formatted_html)
        
        html = f"""
        <div id="summary-popup" class="popup-overlay">
            <div class="popup-content">
                <div class="popup-header">
                    <h2>Hierarchical Abstract</h2>
                    <button onclick="closeSummaryPopup()" class="close-button">×</button>
                </div>
                <div class="popup-body">
                    {summary_html}
                </div>
            </div>
        </div>
        
        <model>
        .popup-overlay {{
            place: fastened;
            high: 0;
            left: 0;
            width: 100%;
            peak: 100%;
            background-color: rgba(0, 0, 0, 0.5);
            z-index: 1000;
            show: flex;
            justify-content: middle;
            align-items: middle;
        }}
        
        .popup-content {{
            background-color: white;
            padding: 20px;
            border-radius: 10px;
            width: 80%;
            max-width: 800px;
            max-height: 80vh;
            overflow-y: auto;
            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
        }}
        
        .popup-header {{
            show: flex;
            justify-content: space-between;
            align-items: middle;
            border-bottom: 1px strong #ddd;
            padding-bottom: 10px;
            margin-bottom: 15px;
        }}
        
        .close-button {{
            background: none;
            border: none;
            font-size: 24px;
            cursor: pointer;
            shade: #555;
        }}
        
        .close-button:hover {{
            shade: #000;
        }}
        
        /* Model for hierarchical bullets */
        .popup-body ul {{
            padding-left: 20px;
            margin-bottom: 5px;
        }}
        
        .popup-body ul.top-level {{
            list-style-type: disc;
        }}
        
        .popup-body ul.second-level {{
            list-style-type: circle;
            margin-top: 5px;
        }}
        
        .popup-body ul.third-level {{
            list-style-type: sq.;
            margin-top: 3px;
        }}
        
        .popup-body li.top-level-item {{
            margin-bottom: 12px;
            font-weight: daring;
        }}
        
        .popup-body li.second-level-item {{
            margin-bottom: 8px;
            font-weight: regular;
        }}
        
        .popup-body li.third-level-item {{
            margin-bottom: 5px;
            font-weight: regular;
            font-size: 0.95em;
        }}
        
        .popup-body p {{
            margin-bottom: 10px;
        }}
        </model>
        
        <script>
        perform closeSummaryPopup() {{
            doc.getElementById('summary-popup').model.show = 'none';
            
            // Ship message to Streamlit
            window.mum or dad.postMessage({{
                kind: "streamlit:setComponentValue",
                worth: true
            }}, "*");
        }}
        </script>
        """
        return html

Speak-to-Video-App generiert Quiz aus dem Video über die QuizGenerator Klasse in quiz.py. Der Quizgenerator erstellt A number of-Selection-Fragen, die auf bestimmte Fakten und Konzepte im Video abzielen. Im Gegensatz zu Rag, bei dem ich eine Null -Temperatur verwende, habe ich die LLM -Temperatur auf 0,4 erhöht, um eine gewisse Kreativität bei der Quizgenerierung zu fördern. Eine strukturierte Eingabeaufforderung führt den Prozess der Quizgenerierung. Der parse_quiz_response Methoden extrahiert und validiert die generierten Quizelemente, um sicherzustellen, dass jede Frage alle erforderlichen Komponenten enthält. Um zu verhindern, dass die Benutzer das Muster erkennen und ein echtes Verständnis fördern, mischt der Quizgenerator die Antwortoptionen. Fragen werden nacheinander Fragen vorgestellt, gefolgt von sofortigem Suggestions zu jeder Antwort. Nachdem alle Fragen gestellt wurden, die calculate_quiz_results Die Methode bewertet Benutzerantworten und der Benutzer wird mit einer Gesamtpunktzahl, einer visuellen Aufschlüsselung von Richtigen gegenüber falschen Antworten und Suggestions auf die Leistungsebene angezeigt. Auf diese Weise verwandelt die Quiz -Era -Funktionalität das passive Video -Ansehen in aktives Lernen, indem sie die Benutzer dazu fordern, Informationen zu erinnern und im Video angegeben.

# quiz.py
class QuizGenerator:
    def __init__(self):
        move
    
    def generate_quiz(self, rag_system, api_key, transcript=None, mannequin="gpt-4o", temperature=0.4):
        """
        Generate quiz questions based mostly on the video transcript
        
        Args:
            rag_system: The RAG system with vector store2
            api_key: OpenAI API key
            transcript: The total transcript textual content (elective)
            mannequin: Mannequin to make use of for query technology
            temperature: Creativity degree (0.0-1.0)
            
        Returns:
            checklist: Record of query objects
        """
        if not rag_system:
            st.error("Please transcribe the video first earlier than making a quiz!")
            return ()
        
        # Create a short lived LLM with barely greater temperature for extra artistic questions
        creative_llm = ChatOpenAI(
            openai_api_key=api_key,
            mannequin=mannequin,
            temperature=temperature
        )

        num_questions = 10
        
        # Immediate to generate quiz
        immediate = f"""Based mostly on the video transcript, generate {num_questions} multiple-choice questions to check understanding of the content material.
        For every query:
        1. The query must be particular to data talked about within the video
        2. Embrace 4 choices (A, B, C, D)
        3. Clearly point out the right reply
        
        Format your response precisely as follows for every query:
        QUESTION: (query textual content)
        A: (choice A)
        B: (choice B)
        C: (choice C)
        D: (choice D)
        CORRECT: (letter of right reply)
       
        Be sure all questions are based mostly on info from the video."""
        
        attempt:
            if transcript:
                # If we've the total transcript, use it
                messages = (
                    {"position": "system", "content material": f"You're given the next transcript from a video:nn{transcript}nnUse this transcript to create quiz questions in keeping with the directions."},
                    {"position": "consumer", "content material": immediate}
                )
                
                response = creative_llm.invoke(messages)
                response_text = response.content material
            else:
                # Fallback to RAG strategy if no transcript is offered
                relevant_docs = rag_system.vector_store.similarity_search(
                    "what are the principle matters lined on this video?", okay=5
                )
                context = "nn".be a part of((doc.page_content for doc in relevant_docs))
                
                # Use the artistic LLM with context to generate questions
                messages = (
                    {"position": "system", "content material": f"You're given the next context from a video transcript:nn{context}nnUse this context to create quiz questions in keeping with the directions."},
                    {"position": "consumer", "content material": immediate}
                )
                
                response = creative_llm.invoke(messages)
                response_text = response.content material
        besides Exception as e:
            # Fallback to the common RAG system if there's an error
            st.warning(f"Utilizing commonplace query technology as a result of error: {str(e)}")
            response_text = rag_system.ask(immediate)
        
        return self.parse_quiz_response(response_text)

    # The remainder of the category stays unchanged
    def parse_quiz_response(self, response_text):
        """
        Parse the LLM response to extract questions, choices, and proper solutions
        
        Args:
            response_text: Uncooked textual content response from LLM
            
        Returns:
            checklist: Record of parsed query objects
        """
        quiz_questions = ()
        current_question = {}
        
        for line in response_text.strip().break up('n'):
            line = line.strip()
            if line.startswith('QUESTION:'):
                if current_question and 'query' in current_question and 'choices' in current_question and 'right' in current_question:
                    quiz_questions.append(current_question)
                current_question = {
                    'query': line(len('QUESTION:'):).strip(),
                    'choices': (),
                    'right': None
                }
            elif line.startswith(('A:', 'B:', 'C:', 'D:')):
                option_letter = line(0)
                option_text = line(2:).strip()
                current_question.setdefault('choices', ()).append((option_letter, option_text))
            elif line.startswith('CORRECT:'):
                current_question('right') = line(len('CORRECT:'):).strip()
        
        # Add the final query
        if current_question and 'query' in current_question and 'choices' in current_question and 'right' in current_question:
            quiz_questions.append(current_question)
        
        # Randomize choices for every query
        randomized_questions = ()
        for q in quiz_questions:
            # Get the unique right reply
            correct_letter = q('right')
            correct_option = None
            
            # Discover the right choice textual content
            for letter, textual content in q('choices'):
                if letter == correct_letter:
                    correct_option = textual content
                    break
            
            if correct_option is None:
                # If we will not discover the right reply, hold the query as is
                randomized_questions.append(q)
                proceed
                
            # Create a listing of choices texts and shuffle them
            option_texts = (textual content for _, textual content in q('choices'))
            
            # Create a duplicate of the unique letters
            option_letters = (letter for letter, _ in q('choices'))
            
            # Create a listing of (letter, textual content) pairs
            options_pairs = checklist(zip(option_letters, option_texts))
            
            # Shuffle the pairs
            random.shuffle(options_pairs)
            
            # Discover the brand new place of the right reply
            new_correct_letter = None
            for letter, textual content in options_pairs:
                if textual content == correct_option:
                    new_correct_letter = letter
                    break
            
            # Create a brand new query with randomized choices
            new_q = {
                'query': q('query'),
                'choices': options_pairs,
                'right': new_correct_letter
            }
            
            randomized_questions.append(new_q)
        
        return randomized_questions
    
    def calculate_quiz_results(self, questions, user_answers):
        """
        Calculate quiz outcomes based mostly on consumer solutions
        
        Args:
            questions: Record of query objects
            user_answers: Dictionary of consumer solutions keyed by question_key
            
        Returns:
            tuple: (outcomes dict, right depend)
        """
        correct_count = 0
        outcomes = {}
        
        for i, query in enumerate(questions):
            question_key = f"quiz_q_{i}"
            user_answer = user_answers.get(question_key)
            correct_answer = query('right')
            
            # Solely depend as right if consumer chosen a solution and it matches
            is_correct = user_answer will not be None and user_answer == correct_answer
            if is_correct:
                correct_count += 1
            
            outcomes(question_key) = {
                'user_answer': user_answer,
                'correct_answer': correct_answer,
                'is_correct': is_correct
            }
        
        return outcomes, correct_count

Speak-to-Movies generiert auch Karteikarten aus dem Videoinhalt, die den aktiven Rückruf und die Wiederholungstechniken der Wiederholung unterstützen. Dies geschieht durch die FlashcardGenerator Klasse in flashcards.pyAnwesend Dies schafft eine Mischung aus verschiedenen Karteikarten, die sich auf wichtige Termsdefinitionen, konzeptionelle Fragen, Aussagen von Anweisungen und wahre/falsche Fragen mit Erklärungen konzentrieren. Eine Eingabeaufforderung führt das LLM, um Flitzkarten in einem strukturierten JSON -Format auszugeben, wobei jede Karte unterschiedliche „Vorder-“ und „Rücken“ enthält. Der shuffle_flashcards Erstellt eine randomisierte Präsentation, und jede Flitzkarte wird validiert, um sicherzustellen, dass sie sowohl vordere als auch hintere Komponenten enthält, bevor sie dem Benutzer präsentiert werden. Die Antwort auf jede FlashCard ist zunächst versteckt. Es wird im Eingang des Benutzers mithilfe einer klassischen Flashcard -Enthüllungsfunktionalität enthüllt. Benutzer können für mehr Übung einen neuen Satz von Karteikarten generieren. Die Flascard- und Quiz -Systeme sind miteinander verbunden, sodass Benutzer nach Bedarf zwischen ihnen wechseln können.

# flashcards.py
class FlashcardGenerator:
    """Class to generate flashcards from video content material utilizing the RAG system."""
    
    def __init__(self):
        """Initialize the flashcard generator."""
        move
    
    def generate_flashcards(self, rag_system, api_key, transcript=None, num_cards=10, mannequin="gpt-4o") -> Record(Dict(str, str)):
        """
        Generate flashcards based mostly on the video content material.
        
        Args:
            rag_system: The initialized RAG system with video content material
            api_key: OpenAI API key
            transcript: The total transcript textual content (elective)
            num_cards: Variety of flashcards to generate (default: 10)
            mannequin: The OpenAI mannequin to make use of
            
        Returns:
            Record of flashcard dictionaries with 'entrance' and 'again' keys
        """
        # Import right here to keep away from round imports
        from langchain_openai import ChatOpenAI
        
        # Initialize language mannequin
        llm = ChatOpenAI(
            openai_api_key=api_key,
            mannequin=mannequin,
            temperature=0.4
        )
        
        # Create the immediate for flashcard technology
        immediate = f"""
        Create {num_cards} academic flashcards based mostly on the video content material.
        
        Every flashcard ought to have:
        1. A entrance facet with a query, time period, or idea
        2. A again facet with the reply, definition, or rationalization
        
        Give attention to an important and academic content material from the video. 
        Create a mixture of various kinds of flashcards:
        - Key time period definitions
        - Conceptual questions
        - Fill-in-the-blank statements
        - True/False questions with explanations
        
        Format your response as a JSON array of objects with 'entrance' and 'again' properties.
        Instance:
        (
            {{"entrance": "What's photosynthesis?", "again": "The method by which vegetation convert gentle vitality into chemical vitality."}},
            {{"entrance": "The three branches of presidency are: Govt, Legislative, and _____", "again": "Judicial"}}
        )
        
        Be sure your output is legitimate JSON format with precisely {num_cards} flashcards.
        """
        
        attempt:
            # Decide the context to make use of
            if transcript:
                # Use the total transcript if offered
                # Create messages for the language mannequin
                messages = (
                    {"position": "system", "content material": f"You're an academic content material creator specializing in creating efficient flashcards. Use the next transcript from a video to create academic flashcards:nn{transcript}"},
                    {"position": "consumer", "content material": immediate}
                )
            else:
                # Fallback to RAG system if no transcript is offered
                relevant_docs = rag_system.vector_store.similarity_search(
                    "key factors and academic ideas within the video", okay=15
                )
                context = "nn".be a part of((doc.page_content for doc in relevant_docs))
                
                # Create messages for the language mannequin
                messages = (
                    {"position": "system", "content material": f"You're an academic content material creator specializing in creating efficient flashcards. Use the next context from a video to create academic flashcards:nn{context}"},
                    {"position": "consumer", "content material": immediate}
                )
            
            # Generate flashcards
            response = llm.invoke(messages)
            content material = response.content material
            
            # Extract JSON content material in case there's textual content round it
            json_start = content material.discover('(')
            json_end = content material.rfind(')') + 1
            
            if json_start >= 0 and json_end > json_start:
                json_content = content material(json_start:json_end)
                flashcards = json.masses(json_content)
            else:
                # Fallback in case of improper JSON formatting
                increase ValueError("Didn't extract legitimate JSON from response")
            
            # Confirm we've the anticipated variety of playing cards (or alter as wanted)
            actual_cards = min(len(flashcards), num_cards)
            flashcards = flashcards(:actual_cards)
            
            # Validate every flashcard has required fields
            validated_cards = ()
            for card in flashcards:
                if 'entrance' in card and 'again' in card:
                    validated_cards.append({
                        'entrance': card('entrance'),
                        'again': card('again')
                    })
            
            return validated_cards
        
        besides Exception as e:
            # Deal with errors gracefully
            print(f"Error producing flashcards: {str(e)}")
            # Return a number of primary flashcards in case of error
            return (
                {"entrance": "Error producing flashcards", "again": f"Please attempt once more. Error: {str(e)}"},
                {"entrance": "Tip", "again": "Strive regenerating flashcards or utilizing a distinct video"}
            )
    
    def shuffle_flashcards(self, flashcards: Record(Dict(str, str))) -> Record(Dict(str, str)):
        """Shuffle the order of flashcards"""
        shuffled = flashcards.copy()
        random.shuffle(shuffled)
        return shuffled

Mögliche Erweiterungen und Verbesserungen

Diese Anwendung kann auf verschiedene Weise erweitert und verbessert werden. Zum Beispiel:

• Die Integration visueller Funktionen in Video (z. B. Keyframes) kann mit Audio untersucht werden, um aussagekräftigere Informationen zu extrahieren.
• Teambasierte Lernerfahrungen können aktiviert werden, wenn Workplace-Kollegen oder Klassenkameraden Notizen, Quiz-Ergebnisse und Zusammenfassungen teilen können.
• Erstellen von navigierbaren Transkripten, mit denen Benutzer auf bestimmte Abschnitte klicken können, um zu diesem Punkt im Video zu springen
• Erstellen Sie schrittweise Aktionspläne für die Implementierung von Konzepten aus dem Video in realen Geschäftsumgebungen
• Ändern Sie die Eingabeaufforderung, die Antworten auszuarbeiten und schwierige Erklärungen für schwierige Konzepte zu geben.
• Erzeugen Sie Fragen, die metakognitive Fähigkeiten bei den Lernenden anregen, indem sie anregen, über ihren Denkprozess und Lernstrategien nachzudenken und gleichzeitig mit Videoinhalten in Kontakt zu treten.

Das sind alles Leute! Wenn Ihnen der Artikel gefallen hat, folgen Sie mir bitte weiter Medium Und LinkedIn.

Gemini Dwell von Google legt mit einer neuen Erweiterung der Sprachunterstützung noch einen drauf. Ab heute können Benutzer mit Gemini Dwell interagieren Französisch, Deutsch, Portugiesisch, Hindi und Spanisch auf Android-Geräten und markiert damit die erste Section einer umfassenderen Spracheinführung, die Google in den kommenden Wochen implementieren will. Das Unternehmen hat sich verpflichtet, Gespräche in mehr als einem Jahr zu unterstützen Bald 40 Sprachenwodurch seine globale Reichweite und Zugänglichkeit verbessert wird.

Der Plan des Unternehmens, Übergänge zwischen zwei Sprachen in einem einzigen Gespräch zu ermöglichen, ist ein bemerkenswerter Fortschritt in der KI-Funktionalität. Mit dieser Entwicklung zielt Gemini Dwell darauf ab, eine globale Nutzerbasis anzusprechen, die sich zunehmend auf einen mehrsprachigen Dialog einlässt. Es wird erwartet, dass diese Funktion, die sich noch in einem frühen Stadium befindet, weiter ausgebaut wird, um eine flüssigere Kommunikation zu ermöglichen und die unterschiedlichen sprachlichen Bedürfnisse der Benutzer zu unterstützen.

Wie stelle ich meine bevorzugten Sprachen auf Gemini Dwell ein?

Um Ihre Spracheinstellungen anzupassen und das Beste aus diesem mehrsprachigen Improve herauszuholen, befolgen Sie ganz einfach die folgenden Schritte:

• Öffnen Sie die Google-App auf Ihrem Android-Gerät und tippen Sie oben auf dem Bildschirm auf Ihr Profilsymbol.
• Gehen Sie hinein Einstellungendann auswählen Google Assistant und schließlich, Sprachen.
• Wählen Sie Ihre bevorzugte Sprache aus verfügbaren Optionen. Möchten Sie mit Gemini Dwell zwei Sprachen sprechen? Sie können auch eine zweite unterstützte Sprache hinzufügen.

Momentan, Zwillinge Dwell unterstützt bis zu zwei Sprachen professional Gerät. Da Google diese Funktion weiterentwickelt, können Nutzer mehr Flexibilität bei der Interaktion mit KI in mehreren Sprachen erwarten

Wetten immer häufiger auf Zwillinge

Parallel zur Spracheinführung stellt Google seine neue Suite vor Gemini-Erweiterungendas erweiterte Kalender-, Aufgaben- und Hold-Funktionen umfasst. Diese Erweiterungen werden in den kommenden Wochen in weiteren Sprachen verfügbar gemacht, was die allgemeine Vielseitigkeit der Plattform erhöht.

Darüber hinaus ersetzt die Utilities-Erweiterung Google Assistant für die Verwaltung von Geräteaufgaben wie das Einstellen von Alarmen, das Steuern von Medien und das Anpassen von Systemeinstellungen wie WLAN und Bluetooth. Gemini Dwell selbst ist jedoch noch nicht mit diesen Erweiterungen kompatibel. Zukünftige Updates könnten sie jedoch möglicherweise integrieren und so seine Fähigkeiten weiter erweitern.

Durch die Erweiterung des Umfangs der unterstützten Sprachen und die Verfeinerung seiner Dienstprogramme positioniert Google Gemini Dwell als leistungsfähigeres Device für alltägliche Benutzer auf der ganzen Welt.

---

Hervorgehobener Bildnachweis: Google

In der sich schnell entwickelnden Landschaft des digitalen Marketings stehen kleine Unternehmen oft an einem Scheideweg und müssen die Anforderungen der Unternehmensführung mit der Notwendigkeit eines effektiven Marketings in Einklang bringen. Angesichts dieser Herausforderung Dauernder Kontakt hat eine bahnbrechende KI-Lösung eingeführt, die speziell auf die Bedürfnisse kleiner und mittlerer Unternehmen (KMU) zugeschnitten ist. Ryan Burke, Director of AI bei Fixed Contact, steht an der Spitze dieser Innovation und bringt jahrzehntelange Erfahrung und Spitzentechnologie mit.

Ryan Burke wird Marketing campaign Builder vorstellen, ein KI-gestütztes Instrument, das die Artwork und Weise revolutionieren soll, wie KMU ihre Marketingkampagnen angehen. Diese bahnbrechende Lösung ist nicht nur eine weitere Ergänzung des Advertising and marketing-Toolkits, sondern ein umfassendes System, das Marketingbemühungen automatisiert und optimiert, sodass sich Geschäftsinhaber mehr auf das konzentrieren können, was sie am besten können – die Führung ihres Unternehmens.

Von der Erstellung überzeugender E-Mail-Texte bis hin zur Auswahl der effektivsten Kanäle für die Kontaktaufnahme nutzt Marketing campaign Builder die umfassende Erfahrung und hochentwickelte KI-Technologie von Fixed Contact, um in Sekundenschnelle maßgeschneiderte Marketingkampagnen zu liefern. Diese Lösung spart Zeit, verbessert die Kampagneneffektivität und gibt Kleinunternehmern, die sich von der Komplexität des digitalen Marketings überfordert fühlen, Vertrauen. Seien Sie dabei, wenn Ryan Burke die Feinheiten dieser innovativen KI-Lösung und ihr Potenzial zur Umgestaltung der Marketinglandschaft für KMUs näherbringt.

Einführung in die KI-Lösung:

Können Sie die neue KI-Lösung beschreiben, die Fixed Contact auf den Markt bringt, und was sie zu einem bahnbrechenden Instrument für kleine Unternehmen macht?

Die meisten kleinen Unternehmen sind nur aus der Not heraus Marketingexperten – sie haben oft keine Zeit für Advertising and marketing und vielen fehlt das Selbstvertrauen und das Wissen, um das Beste aus ihren Kampagnen herauszuholen. Sie brauchen Hilfe bei der Erstellung der richtigen Botschaften für ihre Kunden und beim Verständnis, wo sie diese am besten mit diesen Inhalten erreichen können. Hier kommt Marketing campaign Builder ins Spiel.

Marketing campaign Builder nutzt unsere KI-Plattform sowie Finest Practices aus quick 30 Jahren Erfahrung als Pionier im digitalen Advertising and marketing, um die Marketingbereiche zu automatisieren, in denen KMUs häufig stecken bleiben. In etwa 90 Sekunden erstellt es für Sie eine komplette Marketingkampagne mit überzeugendem Textual content für E-Mails, Social Media und Textnachrichten, gebrandeten E-Mail-Vorlagen und Empfehlungen zu den besten Orten, um Kunden zu erreichen. Dies spart KMUs Zeit und hilft ihnen, ihre Ziele schneller zu erreichen, sodass sie sich auf andere Bereiche ihres Geschäfts konzentrieren können.

Fixed Contact ist derzeit die einzige Marketingplattform, die kleinen und mittleren Unternehmen (KMU) eine derart umfassende automatisierte Generierung von Multi-Channel-Kampagnen bietet.

Zielgruppe:

Wer ist die primäre Zielgruppe dieser KI-Lösung und wie wurde sie an ihre spezifischen Marketinganforderungen angepasst?

Marketing campaign Builder wurde entwickelt, um kleinen Unternehmen und gemeinnützigen Organisationen zu helfen, die Leistung ihrer Kampagnen zu verbessern und gleichzeitig weniger Zeit für Advertising and marketing aufzuwenden. Unsere Untersuchungen zeigen, dass die größten Advertising and marketing-Herausforderungen für KMU darin bestehen, neue Kunden zu finden, herauszufinden, was funktioniert, und Ressourcenmangel. Tatsächlich gaben 56 Prozent der von uns befragten KMU an, dass sie weniger als eine Stunde professional Tag für Advertising and marketing zur Verfügung haben, und 73 Prozent waren sich unsicher, ob ihre Marketingstrategie effektiv ist.

Marketing campaign Builder verändert die Marketingfähigkeiten kleiner und mittelständischer Unternehmen durch eine schnelle und einfache Möglichkeit, ihr Unternehmen zu vermarkten. So können sie weniger Zeit mit Advertising and marketing verbringen und gleichzeitig ihre Taktiken erweitern und die Zuversicht gewinnen, dass sie beim Erreichen ihrer Ziele Fortschritte machen.

KI-Funktionen:

Können Sie die Fähigkeiten dieser KI-Technologie näher erläutern? Wie automatisiert sie konkret Marketingprozesse?

Marketing campaign Builder ist ein zielorientiertes Instrument. Wenn unsere Kunden es zum ersten Mal öffnen, erzählen sie uns ein wenig darüber, was sie mit ihrer Marketingkampagne erreichen möchten – ob es darum geht, ihre Liste zu erweitern, einen Verkauf zu fördern oder sogar für eine Veranstaltung zu werben. Marketing campaign Builder analysiert dann dieses Ziel und entwickelt in Sekundenschnelle einen empfohlenen Satz von Marketingtaktiken, mit denen der Kunde das gewünschte Ergebnis erzielen kann. Dazu gibt es detaillierte Empfehlungen für die besten Inhalte, Kanäle und Zeitpunkte für jede Kommunikation.

Hinter den Kulissen nutzen wir unsere KI-Plattform und unsere Kundendatenplattform (CDP), um ihnen die ganze schwere Arbeit abzunehmen. Fixed Contact wurde vor quick 30 Jahren gegründet, daher wurden unsere KI-Modelle mit historischem Wissen und Daten aus echten digitalen Marketingkampagnen trainiert. Sie lernen, was für verschiedene Arten von Unternehmen am besten funktioniert, und geben dann Empfehlungen ab, die wahrscheinlich zum Erfolg des Kunden führen. Wir integrieren LLMs von OpenAI und anderen, um die Erfahrung der Arbeit mit dem KI-Modelle intuitiv und schnell auch für unsere Kunden.

Benutzererfahrung:

Wie stellt Fixed Contact sicher, dass diese KI-Lösung benutzerfreundlich ist, insbesondere für Kleinunternehmer mit begrenztem technischen Fachwissen?

Wir möchten, dass unsere Kunden erfolgreich sind, weil sie ein großartiges Produkt oder eine großartige Dienstleistung haben, und nicht wegen ihres Marketinggeschicks. Alles, was wir bauen, ist intuitiv, flexibel und leistungsstark, denn das ist es, was kleine Unternehmen brauchen.

Unsere Kunden kommen nicht zu uns, um sozusagen „KI zu kaufen“, und es ist ihnen auch nicht unbedingt wichtig, wie die Technologie im Hintergrund funktioniert. Aber sie wollen, dass Advertising and marketing schneller und leichter verdaulich ist, und sie erwarten, dass sie verstehen, was funktioniert und wo sie Anpassungen vornehmen müssen. Wir haben Marketing campaign Builder unter Berücksichtigung dieses Feedbacks entwickelt und eine geführte Erfahrung geschaffen, mit der sie in Sekundenschnelle Dinge erledigen können, die sonst Stunden oder sogar Tage dauern würden.

Wir empfehlen nicht nur den besten Kommunikationsmix, sondern möglicherweise auch Kanäle, die unsere Benutzer bisher nicht verwendet oder in Betracht gezogen haben, um ihnen dabei zu helfen, ihre Botschaft zu verstärken.

Integration mit vorhandenen Instruments:

Wie intestine lässt sich diese neue KI-Lösung in die bestehende Instrument-Suite von Fixed Contact integrieren?

Unsere Plattform basiert auf KI. Wir haben nutzte diese Technologiezusätzlich zur Marketingautomatisierung, seit Jahren sowohl in kundenorientierten als auch in Backend-Anwendungen wie Personalisierungstools und Spamschutz. Marketing campaign Builder baut einfach auf dieser Grundlage auf und bietet unseren Kunden eine neue Möglichkeit, mit den Options und Funktionen von Fixed Contact zu interagieren, die sie bereits täglich nutzen.

Die von Marketing campaign Builder erstellten Empfehlungen sind Entwickelt für einen reibungslosen Betrieb innerhalb des Workflows eines Kleinunternehmens in Fixed Contact. Jede E-Mail oder Textnachricht kann mit denselben Instruments bearbeitet werden, die unsere Kunden zum manuellen Verfassen von Nachrichten verwenden, und wir nutzen dieselben SMS-Funktionen und Occasion-Plattformen, die bereits in der Plattform vorhanden sind.

Ein Kunde kann all diese Dinge heute manuell in Fixed Contact erledigen, ohne die Hilfe von Marketing campaign Builder. Der Vorteil, mit Marketing campaign Builder zu beginnen, besteht darin, dass der Prozess deutlich schneller ist und seine Kampagnen persönlicher, kreativer und effektiver wirken.

Zukünftige KI-Entwicklungen:

Können Sie uns Einblicke in zukünftige KI-Entwicklungen oder zusätzliche Instruments geben, die Fixed Contact in Betracht zieht?

Wir haben eine klare Imaginative and prescient davon, wohin künstliche Intelligenz uns (und unsere Kunden) in Zukunft führen kann, und untersuchen bereits, wie wir ihren Einsatz erweitern können, um mehr Herausforderungen lösen mit denen KMUs konfrontiert sind. Sie können sich vorstellen, welche Anforderungen das sein könnten – von Suchmaschinenoptimierung über On-line-Werbestrategie bis hin zu Reputationsmanagement und allem, was dazwischen liegt.

Unsere Kunden sind für uns die Vorbilder für unsere Innovationskraft und daher werden wir auch weiterhin großen Wert darauf legen, Funktionen zu entwickeln, die ihnen dabei helfen, neue Kunden zu gewinnen und dafür zu sorgen, dass sie immer wieder zu uns kommen.

Tipps für kleine Unternehmen:

Welchen Rat würden Sie kleinen Unternehmen geben, die KI-Technologien für ihre Marketinganforderungen nutzen möchten?

Es klingt zwar kontraintuitiv, aber machen Sie sich keine Sorgen um die Technologie selbst. KI ist kein Werkzeug, sondern lediglich ein Mittel, mit dem Sie bessere Ergebnisse erzielen können – beispielsweise geistreichere Betreffzeilen verfassen oder wissen, welche Ihrer Kunden Textnachrichten E-Mails vorziehen.

Konzentrieren Sie sich stattdessen darauf, Bereiche Ihres Marketings zu identifizieren, in denen Sie zusätzliche Hilfe benötigen. Vielleicht fällt es Ihnen schwer, Texte für Ihren wöchentlichen E-newsletter zu schreiben, oder Sie haben das Gefühl, dass Ihre Kunden sich nicht so mit Ihren Inhalten beschäftigen, wie sie es sollten. Oder eröffnen Sie bald einen neuen Standort und müssen Interesse für eine große Eröffnung wecken? Das sind die Arten von Dingen, bei denen KI helfen kann, und so erklären wir es unseren Kunden.

Suchen Sie sich einen Accomplice wie Fixed Contact, der die Technologie in Ihrem Namen nutzt, um Instruments zu erstellen, mit denen Sie diese Hindernisse überwinden und sich wieder den Dingen widmen können, die Sie lieber tun.