Erstellen einer API für die English Educator App mit Google Gemini und FastAPI

In der dynamischen Welt von künstliche Intelligenz und super Weiterentwicklung von Generative KI, Entwickler suchen ständig nach innovativen Wegen, um aus Texten sinnvolle Erkenntnisse zu gewinnen. Dieser Blogbeitrag führt Sie durch ein spannendes Projekt, das die Leistungsfähigkeit der Gemini-KI von Google nutzt, um eine intelligente Anwendung für Englischlehrer zu erstellen, die Textdokumente analysiert und schwierige Wörter, mittelschwere Wörter, deren Synonyme, Antonyme und Anwendungsfälle bereitstellt und auch die wichtigen Fragen mit einer Antwort aus dem Text liefert. Ich glaube, dass der Bildungssektor der Sektor ist, der am meisten von den Fortschritten der generativen KI oder LLMs profitiert, und das ist GROSSARTIG!

Lernziele

• Integration von Google Gemini KI-Modellen in Python-basierte APIs.
• Erfahren Sie, wie Sie die API der English Educator App integrieren und nutzen, um Sprachlernanwendungen mit Echtzeitdaten und interaktiven Funktionen zu verbessern.
• Erfahren Sie, wie Sie mit der API der English Educator App individuelle Lerntools erstellen, die Benutzereinbindung verbessern und den Sprachunterricht optimieren können.
• Implementierung einer intelligenten Textanalyse mithilfe erweiterter KI-Eingabeaufforderungen.
• Fehlerfreies Verwalten komplexer KI-Interaktionen mit Fehlerbehandlungstechniken.

Dieser Artikel wurde als Teil des veröffentlicht Data Science-Blogathon.

Was sind APIs?

API (Application Programming Interfaces) dienen als digitale Brücke zwischen verschiedenen Softwareanwendungen. Sie werden als eine Reihe von Protokollen und Regeln definiert, die eine nahtlose Kommunikation ermöglichen und es Entwicklern ermöglichen, auf bestimmte Funktionen zuzugreifen, ohne sich in die komplexe zugrunde liegende Implementierung vertiefen zu müssen.

Was ist REST-API?

REST (Representational State Transfer) ist ein Architekturstil zum Entwerfen vernetzter Anwendungen. Dabei werden standardmäßige HTTP-Methoden verwendet, um Vorgänge an Ressourcen auszuführen.

Wichtige REST-Methoden sind:

• GET: Daten von einem Server abrufen.
• POST: Neue Ressourcen erstellen.
• PUT: Vorhandene Ressourcen vollständig aktualisieren.
• PATCH: Vorhandene Ressourcen teilweise aktualisieren.
• LÖSCHEN: Ressourcen entfernen.

Zu den Hauptmerkmalen gehören:

• Staatenlose Kommunikation
• Einheitliche Schnittstelle
• Client-Serve-Architektur
• Zwischenspeicherbare Ressourcen
• Mehrschichtiger Systemaufbau

REST-APIs verwenden URLs zur Identifizierung von Ressourcen und geben Daten normalerweise im JSON-Format zurück. Sie bieten einen standardisierten, skalierbaren Ansatz für die Kommunikation verschiedener Anwendungen über das Internet und sind daher von grundlegender Bedeutung für die moderne Web- und Mobilentwicklung.

Pydantic und FastAPI: Ein perfektes Paar

Pydantik revolutioniert die Datenvalidierung in Python, indem es Entwicklern ermöglicht, robuste Datenmodelle mit Typhinweisen und Validierungsregeln zu erstellen. Es stellt die Datenintegrität sicher und bietet kristallklare Schnittstellendefinitionen, wodurch potenzielle Fehler erkannt werden, bevor sie sich im System ausbreiten.

FastAPI ergänzt Pydantic wunderbar und bietet ein modernes, leistungsstarkes asynchrones Web-Framework zum Erstellen von APIs.

Der Hauptvorteil von FastAPI:

• Automatische interaktive API-Dokumentation
• Hochgeschwindigkeitsleistung
• Integrierte Unterstützung für Asynchronous Server Gateway Interface
• Intuitive Datenvalidierung
• Saubere und unkomplizierte Syntax

Eine kurze Einführung zu Google Gemini

Google Gemini stellt einen Durchbruch bei multimodalen KI-Modellen dar, die in der Lage sind, komplexe Informationen in Text, Code, Audio und Bild zu verarbeiten. Für dieses Projekt nutze ich das Modell „gemini-1.5-flash“, das Folgendes bietet:

• Schnelle und intelligente Textverarbeitung durch Eingabeaufforderungen.
• Erweitertes Verständnis natürlicher Sprache.
• Flexible Systemanweisungen für benutzerdefinierte Ausgaben mithilfe von Eingabeaufforderungen.
• Fähigkeit, eine differenzierte, kontextbezogene Antwort zu generieren.

Projekt-Setup und Umgebungskonfiguration

Das Einrichten der Entwicklungsumgebung ist für eine reibungslose Implementierung von entscheidender Bedeutung. Wir verwenden Conda, um eine isolierte, reproduzierbare Umgebung zu erstellen

# Create a new conda environment
conda create -n educator-api-env python=3.11

# Activate the environment
conda activate educator-api-env

# Install required packages
pip install "fastapi[standard]" google-generativeai python-dotenv

Projektarchitekturkomponenten

Unsere API ist in drei Hauptkomponenten gegliedert:

• Modelle.py: Definieren von Datenstrukturen und Validierung
• services.py : Implementiert KI-gestützte Textextraktionsdienste
• main.py: Erstellen Sie API-Endpunkte und kümmern Sie sich um die Anforderungsweiterleitung

Erstellen der API: Codeimplementierung

Abrufen des Google Gemini API-Schlüssels und der Sicherheitseinrichtung für das Projekt.

Erstellen Sie eine .env-Datei im Projektstammverzeichnis. Holen Sie sich Ihren Gemini-API-Schlüssel von HIERund fügen Sie Ihren Schlüssel in die .env-Datei ein

GOOGLE_API_KEY="ABCDEFGH-67xGHtsf"

Der Zugriff auf diese Datei erfolgt über das Servicemodul sicher über os.getenv(“ ”). Ihr wichtiger geheimer Schlüssel wird also nicht öffentlich sein.

Pydantic-Modelle: Sicherstellung der Datenintegrität

Wir definieren strukturierte Modelle, die die Datenkonsistenz für die Gemini-Antwort garantieren. Wir implementieren zwei Datenmodelle für jeden Datenextraktionsdienst aus dem Text.

Modell zur Extraktion von Vokabeldaten:

• WortDetails: Es wird das aus der KI extrahierte Wort strukturieren und validieren

from pydantic import BaseModel, Field
from typing import List, Optional


class WordDetails(BaseModel):
    word: str = Field(..., description="Extracted vocabulary word")
    synonyms: List[str] = Field(
        default_factory=list, description="Synonyms of the word"
    )
    antonyms: List[str] = Field(
        default_factory=list, description="Antonyms of the word"
    )
    usecase: Optional[str] = Field(None, description="Use case of the word")
    example: Optional[str] = Field(None, description="Example sentence")

• WortschatzAntwort: Es strukturiert und validiert die extrahierten Wörter in zwei Kategorien: sehr schwierige Wörter und mittelschwere Wörter.

class VocabularyResponse(BaseModel):
    difficult_words: List[WordDetails] = Field(
        ..., description="List of difficult vocabulary words"
    )
    medium_words: List[WordDetails] = Field(
        ..., description="List of medium vocabulary words"
    )

Frage- und Antwort-Extraktionsmodell

• FrageAntwortModell: Es strukturiert und validiert die extrahierten Fragen und Antworten.

class QuestionAnswerModel(BaseModel):
    question: str = Field(..., description="Question")
    answer: str = Field(..., description="Answer")

• FrageAntwortAntwort: Es strukturiert und validiert die extrahierten Antworten der KI.

class QuestionAnswerResponse(BaseModel):
    questions_and_answers: List[QuestionAnswerModel] = Field(
        ..., description="List of questions and answers"
    )

Diese Modelle bieten automatische Validierung, Typprüfung und klare Schnittstellendefinitionen und verhindern so potenzielle Laufzeitfehler.

Leistungsmodul: Intelligente Textverarbeitung

Das Servicemodul verfügt über zwei Dienste:

Dieser Dienst GeminiVocabularyService bietet:

• Verwendet Gemini, um schwierige Wörter zu identifizieren.
• Generiert umfassende Worteinblicke.
• Implementieren Sie eine robuste JSON-Analyse.
• Verwaltet potenzielle Fehlerszenarien.

Zuerst müssen wir alle notwendigen Bibliotheken importieren und die Protokollierungs- und Umgebungsvariablen einrichten.

import os
import json

import logging
from fastapi import HTTPException
import google.generativeai as genai
from dotenv import load_dotenv

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Load environment variables
load_dotenv()

Diese GeminiVocabularyService-Klasse hat drei Methoden.

Die __init__ Die Methode verfügt über eine wichtige Gemini-Konfiguration, einen Google API-Schlüssel, ein generatives Modell zum Einstellen und eine Eingabeaufforderung zur Vokabelextraktion.

Prompt:

"""You are an expert vocabulary extractor. 
For the given text:
            1. Identify 3-5 challenging vocabulary words
            2. Provide the following for EACH word in a STRICT JSON format:
            - word: The exact word
            - synonyms: List of 2-3 synonyms
            - antonyms: List of 2-3 antonyms
            - usecase: A brief explanation of the word's usage
            - example: An example sentence using the word

            IMPORTANT: Return ONLY a valid JSON that matches this structure:
            {
              "difficult_words": [
                {
                  "word": "string",
                  "synonyms": ["string1", "string2"],
                  "antonyms": ["string1", "string2"],
                  "usecase": "string",
                  "example": "string"
                }
              ],
              "medium_words": [
                {
                  "word": "string",
                  "synonyms": ["string1", "string2"],
                  "antonyms": ["string1", "string2"],
                  "usecase": "string",
                  "example": "string"
                }
              ],
            }
            """           

Code-Implementierung

class GeminiVocabularyService:
    def __init__(self):
        _google_api_key = os.getenv("GOOGLE_API_KEY")
        # Retrieve API Key
        self.api_key = _google_api_key
        if not self.api_key:
            raise ValueError(
                "Google API Key is missing. Please set GOOGLE_API_KEY in .env file."
            )

        # Configure Gemini API
        genai.configure(api_key=self.api_key)

        # Generation Configuration
        self.generation_config = {
            "temperature": 0.7,
            "top_p": 0.95,
            "max_output_tokens": 8192,
        }

        # Create Generative Model
        self.vocab_model = genai.GenerativeModel(
            model_name="gemini-1.5-flash",
            generation_config=self.generation_config,  # type: ignore
            system_instruction="""
            You are an expert vocabulary extractor. 
            For the given text:
            1. Identify 3-5 challenging vocabulary words
            2. Provide the following for EACH word in a STRICT JSON format:
            - word: The exact word
            - synonyms: List of 2-3 synonyms
            - antonyms: List of 2-3 antonyms
            - usecase: A brief explanation of the word's usage
            - example: An example sentence using the word

            IMPORTANT: Return ONLY a valid JSON that matches this structure:
            {
              "difficult_words": [
                {
                  "word": "string",
                  "synonyms": ["string1", "string2"],
                  "antonyms": ["string1", "string2"],
                  "usecase": "string",
                  "example": "string"
                }
              ],
              "medium_words": [
                {
                  "word": "string",
                  "synonyms": ["string1", "string2"],
                  "antonyms": ["string1", "string2"],
                  "usecase": "string",
                  "example": "string"
                }
              ],
            }
            """,
        )

Die Methode „extracted_vocabulary“ umfasst den Chat-Prozess und die Antwort von Gemini durch Senden einer Texteingabe mithilfe der Funktion „sending_message_async()“. Diese Methode verfügt über eine private Hilfsfunktion „_parse_response()“. Diese private Hilfsfunktion validiert die Antwort von Gemini, überprüft die erforderlichen Parameter und analysiert dann die Daten in die Funktion „extrahiertes Vokabular“. Außerdem protokolliert sie Fehler wie „JSONDecodeError“ und „ValueError“ für ein besseres Fehlermanagement.

Code-Implementierung

Die Methode „extracted_vocabulary“:

async def extract_vocabulary(self, text: str) -> dict:
        try:
            # Create a new chat session
            chat_session = self.vocab_model.start_chat(history=[])

            # Send message and await response
            response = await chat_session.send_message_async(text)

            # Extract and clean the text response
            response_text = response.text.strip()

            # Attempt to extract JSON
            return self._parse_response(response_text)

        except Exception as e:
            logger.error(f"Vocabulary extraction error: {str(e)}")
            logger.error(f"Full response: {response_text}")
            raise HTTPException(
                status_code=500, detail=f"Vocabulary extraction failed: {str(e)}"
            )

Die Methode _parsed_response:

def _parse_response(self, response_text: str) -> dict:
        # Remove markdown code blocks if present
        response_text = response_text.replace("```json", "").replace("```", "").strip()

        try:
            # Attempt to parse JSON
            parsed_data = json.loads(response_text)

            # Validate the structure
            if (
                not isinstance(parsed_data, dict)
                or "difficult_words" not in parsed_data
            ):
                raise ValueError("Invalid JSON structure")

            return parsed_data

        except json.JSONDecodeError as json_err:
            logger.error(f"JSON Decode Error: {json_err}")
            logger.error(f"Problematic response: {response_text}")
            raise HTTPException(
                status_code=400, detail="Invalid JSON response from Gemini"
            )
        except ValueError as val_err:
            logger.error(f"Validation Error: {val_err}")
            raise HTTPException(
                status_code=400, detail="Invalid vocabulary extraction response"
            )

Der vollständige CODE des GeminiVocabularyService-Moduls.

class GeminiVocabularyService:
    def __init__(self):
        _google_api_key = os.getenv("GOOGLE_API_KEY")
        # Retrieve API Key
        self.api_key = _google_api_key
        if not self.api_key:
            raise ValueError(
                "Google API Key is missing. Please set GOOGLE_API_KEY in .env file."
            )

        # Configure Gemini API
        genai.configure(api_key=self.api_key)

        # Generation Configuration
        self.generation_config = {
            "temperature": 0.7,
            "top_p": 0.95,
            "max_output_tokens": 8192,
        }

        # Create Generative Model
        self.vocab_model = genai.GenerativeModel(
            model_name="gemini-1.5-flash",
            generation_config=self.generation_config,  # type: ignore
            system_instruction="""
            You are an expert vocabulary extractor. 
            For the given text:
            1. Identify 3-5 challenging vocabulary words
            2. Provide the following for EACH word in a STRICT JSON format:
            - word: The exact word
            - synonyms: List of 2-3 synonyms
            - antonyms: List of 2-3 antonyms
            - usecase: A brief explanation of the word's usage
            - example: An example sentence using the word

            IMPORTANT: Return ONLY a valid JSON that matches this structure:
            {
              "difficult_words": [
                {
                  "word": "string",
                  "synonyms": ["string1", "string2"],
                  "antonyms": ["string1", "string2"],
                  "usecase": "string",
                  "example": "string"
                }
              ],
              "medium_words": [
                {
                  "word": "string",
                  "synonyms": ["string1", "string2"],
                  "antonyms": ["string1", "string2"],
                  "usecase": "string",
                  "example": "string"
                }
              ],
            }
            """,
        )

    async def extract_vocabulary(self, text: str) -> dict:
        try:
            # Create a new chat session
            chat_session = self.vocab_model.start_chat(history=[])

            # Send message and await response
            response = await chat_session.send_message_async(text)

            # Extract and clean the text response
            response_text = response.text.strip()

            # Attempt to extract JSON
            return self._parse_response(response_text)

        except Exception as e:
            logger.error(f"Vocabulary extraction error: {str(e)}")
            logger.error(f"Full response: {response_text}")
            raise HTTPException(
                status_code=500, detail=f"Vocabulary extraction failed: {str(e)}"
            )

    def _parse_response(self, response_text: str) -> dict:
        # Remove markdown code blocks if present
        response_text = response_text.replace("```json", "").replace("```", "").strip()

        try:
            # Attempt to parse JSON
            parsed_data = json.loads(response_text)

            # Validate the structure
            if (
                not isinstance(parsed_data, dict)
                or "difficult_words" not in parsed_data
            ):
                raise ValueError("Invalid JSON structure")

            return parsed_data

        except json.JSONDecodeError as json_err:
            logger.error(f"JSON Decode Error: {json_err}")
            logger.error(f"Problematic response: {response_text}")
            raise HTTPException(
                status_code=400, detail="Invalid JSON response from Gemini"
            )
        except ValueError as val_err:
            logger.error(f"Validation Error: {val_err}")
            raise HTTPException(
                status_code=400, detail="Invalid vocabulary extraction response"
            )

Frage-Antwort-Generierungsdienst

Dieser Frage-Antwort-Service bietet:

• Erstellt kontextreiche Verständnisfragen.
• Erzeugt präzise, ​​informative Antworten.
• Bewältigt komplexe Anforderungen an die Textanalyse.
• JSON- und Wertfehlerbehandlung.

Dieser QuestionAnswerService verfügt über drei Methoden:

__init__-Methode

 Die Methode __init__ ist mit Ausnahme der Eingabeaufforderung größtenteils identisch mit der Vocabulary-Dienstklasse.

Prompt:

"""
            You are an expert at creating comprehensive comprehension questions and answers.
            For the given text:
            1. Generate 8-10 diverse questions covering:
               - Vocabulary meaning
               - Literary devices
               - Grammatical analysis
               - Thematic insights
               - Contextual understanding

            IMPORTANT: Return ONLY a valid JSON in this EXACT format:
            {
              "questions_and_answers": [
                {
                  "question": "string",
                  "answer": "string"
                }
              ]
            }

            Guidelines:
            - Questions should be clear and specific
            - Answers should be concise and accurate
            - Cover different levels of comprehension
            - Avoid yes/no questions
            """           

Code-Implementierung:

Die __init__-Methode der QuestionAnswerService-Klasse

def __init__(self):
        _google_api_key = os.getenv("GOOGLE_API_KEY")
        # Retrieve API Key
        self.api_key = _google_api_key
        if not self.api_key:
            raise ValueError(
                "Google API Key is missing. Please set GOOGLE_API_KEY in .env file."
            )

        # Configure Gemini API
        genai.configure(api_key=self.api_key)

        # Generation Configuration
        self.generation_config = {
            "temperature": 0.7,
            "top_p": 0.95,
            "max_output_tokens": 8192,
        }

        self.qa_model = genai.GenerativeModel(
            model_name="gemini-1.5-flash",
            generation_config=self.generation_config,  # type: ignore
            system_instruction="""
            You are an expert at creating comprehensive comprehension questions and answers.
            For the given text:
            1. Generate 8-10 diverse questions covering:
               - Vocabulary meaning
               - Literary devices
               - Grammatical analysis
               - Thematic insights
               - Contextual understanding

            IMPORTANT: Return ONLY a valid JSON in this EXACT format:
            {
              "questions_and_answers": [
                {
                  "question": "string",
                  "answer": "string"
                }
              ]
            }

            Guidelines:
            - Questions should be clear and specific
            - Answers should be concise and accurate
            - Cover different levels of comprehension
            - Avoid yes/no questions
            """,
        )

Die Frage- und Antwortextraktion

Die Methode extract_questions_and_answers verfügt über eine Chat-Sitzung mit Gemini, eine vollständige Eingabeaufforderung zur besseren Extraktion von Fragen und Antworten aus dem Eingabetext, eine asynchrone Nachricht, die mit send_message_async(full_prompt) an die Gemini-API gesendet wird, und anschließendes Entfernen der Antwortdaten für saubere Daten. Diese Methode verfügt genau wie die vorherige auch über eine private Hilfsfunktion.

Code-Implementierung:

Fragen und Antworten extrahieren

async def extract_questions_and_answers(self, text: str) -> dict:
        """
        Extracts questions and answers from the given text using the provided model.
        """
        try:
            # Create a new chat session
            chat_session = self.qa_model.start_chat(history=[])

            full_prompt = f"""
            Analyze the following text and generate comprehensive comprehension questions and answers:

            {text}

            Ensure the questions and answers provide deep insights into the text's meaning, style, and context.
            """

            # Send message and await response
            response = await chat_session.send_message_async(full_prompt)

            # Extract and clean the text response
            response_text = response.text.strip()

            # Attempt to parse and validate the response
            return self._parse_response(response_text)

        except Exception as e:
            logger.error(f"Question and answer extraction error: {str(e)}")
            logger.error(f"Full response: {response_text}")
            raise HTTPException(
                status_code=500, detail=f"Question-answer extraction failed: {str(e)}"
            )

_Antwort analysieren

def _parse_response(self, response_text: str) -> dict:
        """
        Parses and validates the JSON response from the model.
        """
        # Remove markdown code blocks if present
        response_text = response_text.replace("```json", "").replace("```", "").strip()

        try:
            # Attempt to parse JSON
            parsed_data = json.loads(response_text)

            # Validate the structure
            if (
                not isinstance(parsed_data, dict)
                or "questions_and_answers" not in parsed_data
            ):
                raise ValueError("Response must be a list of questions and answers.")

            return parsed_data

        except json.JSONDecodeError as json_err:
            logger.error(f"JSON Decode Error: {json_err}")
            logger.error(f"Problematic response: {response_text}")
            raise HTTPException(
                status_code=400, detail="Invalid JSON response from the model"
            )
        except ValueError as val_err:
            logger.error(f"Validation Error: {val_err}")
            raise HTTPException(
                status_code=400, detail="Invalid question-answer extraction response"
            )

API-Endpunkte: Benutzer mit KI verbinden

Die Hauptdatei definiert zwei primäre POST-Endpunkte:

Es handelt sich um eine Post-Methode, die in erster Linie Eingabedaten von den Clients verwendet und diese über den Vokabelextraktionsdienst an die KI-APIs sendet. Außerdem wird der Eingabetext auf Mindestwortanzahl geprüft und die Antwortdaten werden schließlich mithilfe des Pydantic-Modells auf Konsistenz überprüft und im Speicher abgelegt. 

@app.post("/extract-vocabulary/", response_model=VocabularyResponse)
async def extract_vocabulary(text: str):
    # Validate input
    if not text or len(text.strip()) < 10:
        raise HTTPException(status_code=400, detail="Input text is too short")

    # Extract vocabulary
    result = await vocab_service.extract_vocabulary(text)

    # Store vocabulary in memory
    key = hash(text)
    vocabulary_storage[key] = VocabularyResponse(**result)

    return vocabulary_storage[key]

Diese Post-Methode ist größtenteils identisch mit der vorherigen POST-Methode, außer dass sie den Question Answer Extraction Service verwendet.

@app.post("/extract-question-answer/", response_model=QuestionAnswerResponse)
async def extract_question_answer(text: str):
    # Validate input
    if not text or len(text.strip()) < 10:
        raise HTTPException(status_code=400, detail="Input text is too short")

    # Extract vocabulary
    result = await qa_service.extract_questions_and_answers(text)

    # Store result for retrieval (using hash of text as key for simplicity)
    key = hash(text)
    qa_storage[key] = QuestionAnswerResponse(**result)

    return qa_storage[key]

Es gibt zwei primäre GET-Methoden:

Zuerst prüft die Methode get-vocabulary den Hash-Schlüssel mit den Textdaten des Clients. Wenn die Textdaten im Speicher vorhanden sind, wird das Vokabular als JSON-Daten dargestellt. Diese Methode wird verwendet, um die Daten auf der CLIENT-SIDE-Benutzeroberfläche auf der Webseite anzuzeigen.

@app.get("/get-vocabulary/", response_model=Optional[VocabularyResponse])
async def get_vocabulary(text: str):
    """
    Retrieve the vocabulary response for a previously processed text.
    """
    key = hash(text)
    if key in vocabulary_storage:
        return vocabulary_storage[key]
    else:
        raise HTTPException(
            status_code=404, detail="Vocabulary result not found for the provided text"
        )

Zweitens überprüft die Methode „Get-Question-Answer“ wie die vorherige Methode auch den Hash-Schlüssel mit den Textdaten des Clients und generiert die im Speicher gespeicherte JSON-Antwort an die CLIENT-SIDE-Benutzeroberfläche.

@app.get("/get-question-answer/", response_model=Optional[QuestionAnswerResponse])
async def get_question_answer(text: str):
    """
    Retrieve the question-answer response for a previously processed text.
    """
    key = hash(text)
    if key in qa_storage:
        return qa_storage[key]
    else:
        raise HTTPException(
            status_code=404,
            detail="Question-answer result not found for the provided text",
        )

Wichtiges Implementierungsmerkmal

Um die Anwendung auszuführen, müssen wir die Bibliotheken importieren und einen FastAPI-Dienst instanziieren.

Bibliotheken importieren

from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from typing import Optional

from .models import VocabularyResponse, QuestionAnswerResponse
from .services import GeminiVocabularyService, QuestionAnswerService

Instanziieren der FastAPI-Anwendung

# FastAPI Application
app = FastAPI(title="English Educator API")

Unterstützung für Cross-Origin Resource Sharing (CORS)

Cross-Origin Resource Sharing (CORS) ist ein HTTP-Header-basierter Mechanismus, der es einem Server ermöglicht, alle Ursprünge wie Domänen, Schemata oder Ports außer seinen eigenen anzugeben, von denen ein Browser das Laden von Ressourcen zulassen soll. Aus Sicherheitsgründen beschränkt der Browser CORS-HTTP-Anfragen, die von Skripten initiiert werden.

# FastAPI Application
app = FastAPI(title="English Educator API")

# Add CORS middleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

In-Memory-Validierungsmechanismus: Simple Key Word Storage

Wir verwenden für das Projekt einen einfachen schlüsselwertbasierten Speicher, Sie können aber auch MongoDB verwenden.

# Simple keyword storage

vocabulary_storage = {}
qa_storage = {}

Eingabevalidierungsmechanismen und umfassende Fehlerbehandlung.

Jetzt ist es an der Zeit, die Anwendung auszuführen.

Um die Anwendung im Entwicklungsmodus auszuführen, müssen wir FasyAPI CLI verwenden, das mit FastAPI installiert wird.
Geben Sie den Code in das Anwendungsstammverzeichnis Ihres Terminals ein.

$ fastapi dev main.py

Ausgang:

Wenn Sie dann STRG + Rechtsklick auf den Link drücken http://127.0.0.1:8000 Sie erhalten einen Begrüßungsbildschirm im Webbrowser.

Um zur Dokumentationsseite von FastAPI zu gelangen, klicken Sie einfach auf die nächste URL oder geben Sie ein http://127.0.0.1:8000/docs in Ihrem Browser, und Sie sehen alle HTTP-Methoden zum Testen auf der Seite.

Um die API zu testen, klicken Sie auf eine der POST-Methoden und PROBIEREN SIE SIE AUS. Geben Sie den gewünschten Text in das Eingabefeld ein und führen Sie sie aus. Sie erhalten die Antwort entsprechend den Diensten, z. B. Vokabular und Fragen-Antwort.

Execute:

Antwort:

Execute:

Antwort:

Testen von Get-Methoden

Vokabeln aus dem Speicher holen.

Execute:

Geben Sie in das Eingabefeld denselben Text ein, den Sie in die POST-Methode eingegeben haben.

Antwort:

Sie erhalten die folgende Ausgabe aus dem Speicher.

und auch für Fragen und Antworten

Execute:

Antwort:

Dabei handelt es sich um eine vollständig funktionsfähige Webserver-API für Englischlehrer, die Google Gemini AI verwenden.

Weitere Entwicklungsmöglichkeiten

Die aktuelle Implementierung öffnet Türen für spannende zukünftige Verbesserungen:

• Entdecken Sie dauerhafte Speicherlösungen, um Daten über Sitzungen hinweg effektiv aufzubewahren.
• Integrieren Sie robuste Authentifizierungsmechanismen für mehr Sicherheit.
• Erweiterte Textanalysefunktionen mit ausgefeilteren Features.
• Entwerfen und erstellen Sie eine intuitive Front-End-Schnittstelle für eine bessere Benutzerinteraktion.
• Implementieren Sie effiziente Strategien zur Ratenbegrenzung und Zwischenspeicherung, um die Leistung zu optimieren.

Praktische Überlegungen und Einschränkungen

Obwohl unsere API über leistungsstarke Funktionen verfügt, sollten Sie Folgendes berücksichtigen:

• Berücksichtigen Sie bei der Nutzungsplanung die Kosten und Ratenbegrenzungen der API-Nutzung, um unerwartete Gebühren zu vermeiden und Skalierbarkeit sicherzustellen.
• Bedenken Sie die Verarbeitungszeit komplexer Texte, da längere oder kompliziertere Eingaben zu längeren Reaktionszeiten führen können.
• Bereiten Sie sich auf kontinuierliche Modellaktualisierungen von Google vor, die sich im Laufe der Zeit auf die Leistung oder Funktionen der API auswirken können.
• Bedenken Sie, dass die von KI generierten Antworten unterschiedlich ausfallen können. Daher ist es wichtig, mögliche Inkonsistenzen bei der Ausgabequalität zu berücksichtigen.

Schlussfolgerung

Wir haben eine flexible, intelligente API entwickelt, die die Textanalyse durch die Synergie von Google Gemini, FastAPI und Pydantic transformiert. Diese Lösung zeigt, wie moderne KI-Technologien genutzt werden können, um tiefe, aussagekräftige Erkenntnisse aus Textdaten zu gewinnen.

Den gesamten Code des Projekts finden Sie im CODE REPO.

Key Take Away

• KI-gestützte APIs können eine intelligente, kontextbezogene Textanalyse ermöglichen.
• FastAPI vereinfacht die komplexe API-Entwicklung durch automatische Dokumentation.
• Mit der API der English Educator App können Entwickler interaktive und personalisierte Sprachlernerlebnisse schaffen.
• Durch die Integration der API der English Educator App können Sie die Bereitstellung von Inhalten optimieren und so sowohl die Bildungsergebnisse als auch das Engagement der Benutzer verbessern.

Oft gestellte Frage

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Ich bin ein autodidaktischer, projektorientierter Lerner, der gerne an komplexen Projekten zu Deep Learning, Computer Vision und NLP arbeitet. Ich versuche immer, ein tiefes Verständnis für das Thema zu erlangen, das in jedem Bereich liegen kann, wie Deep Learning, maschinelles Lernen oder Physik. Ich liebe es, Inhalte zu meinem Lernen zu erstellen. Ich versuche, mein Verständnis mit der Welt zu teilen.

• SEO-gestützte Content- und PR-Distribution. Holen Sie sich noch heute Verstärkung.
• PlatoData.Network Vertikale generative KI. Motiviere dich selbst. Hier zugreifen.
• PlatoAiStream. Web3-Intelligenz. Wissen verstärkt. Hier zugreifen.
• PlatoESG. Kohlenstoff, CleanTech, Energie, Umwelt, Solar, Abfallwirtschaft. Hier zugreifen.
• PlatoHealth. Informationen zu Biotechnologie und klinischen Studien. Hier zugreifen.
• Quelle: https://www.analyticsvidhya.com/blog/2024/12/english-educator-app-api/