Een API voor een Engelse onderwijsapp bouwen met Google Gemini en FastAPI

In de dynamische wereld van kunstmatige intelligentie en super vooruitgang van generatieve AI, ontwikkelaars zijn voortdurend op zoek naar innovatieve manieren om zinvolle inzichten uit tekst te halen. Deze blogpost leidt je door een spannend project dat de kracht van Google's Gemini AI benut om een ​​intelligente English Educator Application te creëren die tekstdocumenten analyseert en moeilijke woorden, middelmatige woorden, hun synoniemen, antoniemen, use-cases biedt en ook de belangrijke vragen met een antwoord uit de tekst biedt. Ik geloof dat onderwijs de sector is die het meest profiteert van de vooruitgang van Generative AI's of LLM's en het is GEWELDIG!

Leerdoelen

• Integratie van Google Gemini AI-modellen in Python-gebaseerde API's.
• Leer hoe u de English Educator App API kunt integreren en gebruiken om taaltoepassingen te verbeteren met realtime gegevens en interactieve functies.
• Ontdek hoe u de English Educator App API kunt gebruiken om aangepaste educatieve hulpmiddelen te bouwen, de betrokkenheid van gebruikers te vergroten en het taalonderwijs te optimaliseren.
• Implementatie van intelligente tekstuele analyse met behulp van geavanceerde AI-prompts.
• Complexe AI-interacties foutloos beheren met foutbehandelingstechnieken.

Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon.

Wat zijn API's?

API's (Application Programming Interfaces) dienen als een digitale brug tussen verschillende softwaretoepassingen. Ze worden gedefinieerd als een set protocollen en regels die naadloze communicatie mogelijk maken, waardoor ontwikkelaars toegang hebben tot specifieke functionaliteiten zonder zich te verdiepen in complexe onderliggende implementaties.

Wat is REST-API?

REST (Representational State Transfer) is een architectuurstijl voor het ontwerpen van netwerktoepassingen. Het gebruikt standaard HTTP-methoden om bewerkingen op resources uit te voeren.

Belangrijke REST-methoden zijn:

• GET: Gegevens ophalen van een server.
• POST: Nieuwe bronnen maken.
• PUT: Bestaande bronnen volledig bijwerken.
• PATCH: Bestaande bronnen gedeeltelijk bijwerken.
• VERWIJDEREN: Verwijder bronnen.

Belangrijke kenmerken zijn:

• Staatloze communicatie
• Uniforme interface
• Client-Serve-architectuur
• Cachebare bronnen
• Gelaagd systeemontwerp

REST API's gebruiken URL's om bronnen te identificeren en retourneren doorgaans gegevens in JSON-formaten. Ze bieden een gestandaardiseerde, schaalbare aanpak voor verschillende applicaties om via internet te communiceren, waardoor ze fundamenteel zijn in moderne web- en mobiele ontwikkeling.

Pydantic en FastAPI: een perfect paar

Pydantisch revolutioneert datavalidatie in Python door ontwikkelaars in staat te stellen robuuste datamodellen te maken met typehints en validatieregels. Het zorgt voor data-integriteit en biedt kristalheldere interfacedefinities, waardoor potentiële fouten worden opgevangen voordat ze zich door het systeem verspreiden.

FastAPI vormt een prachtige aanvulling op Pydantic en biedt een modern, krachtig asynchroon webframework voor het bouwen van API's.

Het belangrijkste voordeel van FastAPI:

• Automatische interactieve API-documentatie
• Prestaties op hoge snelheid
• Ingebouwde ondersteuning voor Asynchronous Server Gateway Interface
• Intuïtieve gegevensvalidatie
• Schone en eenvoudige syntaxis

Een korte uitleg over Google Gemini

Google Gemini vertegenwoordigt een doorbraak in multimodale AI-modellen, die complexe informatie over tekst, code, audio en afbeeldingen kunnen verwerken. Voor dit project maak ik gebruik van het 'gemini-1.5-flash'-model, dat het volgende biedt:

• Snelle en intelligente tekstverwerking met behulp van prompts.
• Geavanceerd begrip van natuurlijke taal.
• Flexibele systeeminstructies voor aangepaste uitvoer met behulp van prompts.
• Vermogen om een ​​genuanceerd, contextbewust antwoord te geven.

Projectinstellingen en omgevingsconfiguratie

Het opzetten van de ontwikkelomgeving is cruciaal voor een soepele implementatie. We gebruiken Conda om een ​​geïsoleerde, reproduceerbare omgeving te creëren

# 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

Projectarchitectuurcomponenten

Onze API is gestructureerd in drie primaire componenten:

• modellen.py : Definieer datastructuren en validatie
• diensten.py : Implementeert op AI gebaseerde tekst-extractieservices
• hoofd.py : API-eindpunten maken en verzoekroutering afhandelen

API bouwen: code-implementatie

Google Gemini API-sleutel en beveiliging instellen voor het project.

Maak een .env-bestand in de projectroot, haal uw Gemini API-sleutel op van hier, en plaats uw sleutel in het .env-bestand

GOOGLE_API_KEY="ABCDEFGH-67xGHtsf"

Dit bestand wordt veilig benaderd door de servicemodule met behulp van os.getenv(“ ”). Uw belangrijke geheime sleutel zal dus niet openbaar zijn.

Pydantic-modellen: data-integriteit garanderen

We definiëren gestructureerde modellen die dataconsistentie garanderen voor de Gemini-respons. We implementeren twee datamodellen voor elke data-extractieservice uit de tekst.

Model voor extractie van woordenschatgegevens:

• WoordDetails: Het zal het geëxtraheerde woord uit de AI structureren en valideren

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")

• WoordenschatReactie: De geëxtraheerde woorden worden gestructureerd en gevalideerd in twee categorieën: zeer moeilijke woorden en middelmoeilijke woorden.

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"
    )

Vraag- en antwoordextractiemodel

• VraagAntwoordModel: Het zal de geëxtraheerde vragen en antwoorden structureren en valideren.

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

• VraagAntwoordReactie: Het zal de geëxtraheerde reacties van de AI structureren en valideren.

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

Deze modellen bieden automatische validatie, typecontrole en duidelijke interfacedefinities, waardoor potentiële runtime-fouten worden voorkomen.

Servicemodule: Intelligente tekstverwerking

De servicemodule heeft twee services:

Deze service GeminiVocabularyService biedt:

• Gebruikt Tweelingen om moeilijke woorden te identificeren.
• Genereert uitgebreide woordinzichten.
• Implementeer robuuste JSON-parsing.
• Beheert mogelijke foutscenario's.

Eerst moeten we alle benodigde bibliotheken importeren en de log- en omgevingsvariabelen instellen.

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()

Deze GeminiVocabularyService-klasse heeft drie methoden.

De __in het__ De methode heeft een belangrijke Gemini-configuratie, Google API-sleutel, generatief modelinstelling en prompt voor het extraheren van de woordenschat.

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 Implementatie

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"
                }
              ],
            }
            """,
        )

De extracted_vocabulary methode heeft het chatproces en respons van de Gemini door tekstinvoer te verzenden met behulp van de sending_message_async() functie. Deze methode heeft één privé-utility functie _parse_response(). Deze privé-utility functie valideert de respons van de Gemini, controleert de benodigde parameters en parseert de data vervolgens naar de extracted vocabulary functie. Het logt ook de fouten zoals JSONDecodeError en ValueError voor beter foutbeheer.

Code Implementatie

De extracted_vocabulary-methode:

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)}"
            )

De _parsed_response-methode:

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"
            )

De volledige CODE van de GeminiVocabularyService-module.

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"
            )

Vraag-antwoord generatie service

Deze Vraag- en Antwoordservice biedt de volgende faciliteiten:

• Stelt contextuele, begrijpelijke vragen.
• Geeft nauwkeurige, informatieve antwoorden.
• Kan complexe tekstuele analyses uitvoeren.
• JSON- en waardefoutverwerking.

Deze QuestionAnswerService heeft drie methoden:

__init__ methode

 De __init__-methode is grotendeels hetzelfde als de Vocabulary-serviceklasse, behalve wat betreft de prompt.

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-implementatie:

De __init__-methode van de 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
            """,
        )

De vraag- en antwoordextractie

De extract_questions_and_answers methode heeft een chatsessie met Gemini, een volledige prompt voor betere extractie van vragen en antwoorden uit de invoertekst, een asynchroon bericht verzonden naar de Gemini API met send_message_async(full_prompt), en vervolgens het strippen van responsgegevens voor schone gegevens. Deze methode heeft ook een privé-hulpprogrammafunctie, net als de vorige.

Code-implementatie:

extract_vragen_en_antwoorden

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)}"
            )

_parse_response

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-eindpunten: gebruikers verbinden met AI

Het hoofdbestand definieert twee primaire POST-eindpunten:

Het is een postmethode die voornamelijk invoergegevens van de clients zal consumeren en deze via de Vocabulary Extraction Service naar de AI API's zal sturen. Het zal ook de invoertekst controleren op minimale woordvereisten en tenslotte zal het de responsgegevens valideren met behulp van het Pydantic-model op consistentie en deze opslaan in de opslag. 

@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]

Deze postmethode heeft grotendeels dezelfde kenmerken als de vorige POST-methode, behalve dat er gebruik wordt gemaakt van de Question Answer Extraction Service.

@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]

Er zijn twee primaire GET-methoden:

Eerst controleert de get-vocabulary methode de hash-sleutel met de tekstgegevens van de clients. Als de tekstgegevens in de opslag aanwezig zijn, wordt de vocabulaire gepresenteerd als JSON-gegevens. Deze methode wordt gebruikt om de gegevens op de CLIENT SIDE UI op de webpagina te tonen.

@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"
        )

Ten tweede controleert de get-question-answer-methode de hashsleutel met de tekstgegevens van de client, net als bij de vorige methode. Vervolgens wordt het JSON-antwoord dat in de opslag is opgeslagen, naar de CLIENT SIDE UI gestuurd.

@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",
        )

Belangrijkste implementatiefunctie

Om de applicatie uit te voeren, moeten we de bibliotheken importeren en een FastAPI-service instantiëren.

Bibliotheken importeren

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

Instantieer FastAPI-applicatie

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

Ondersteuning voor Cross-origin Resource Sharing (CORS)

Cross-origin resource sharing (CORS) is een HTTP-header-gebaseerd mechanisme waarmee een server alle oorsprongen kan aangeven, zoals domein, schema of poort anders dan de eigen oorsprong, van waaruit een browser het laden van bronnen moet toestaan. Om veiligheidsredenen beperkt de browser CORS HTTP-verzoeken die vanuit scripts worden geïnitieerd.

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

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

Validatiemechanisme in het geheugen: eenvoudige opslag van trefwoorden

Wij gebruiken eenvoudige sleutel-waarde-gebaseerde opslag voor het project, maar u kunt MongoDB gebruiken.

# Simple keyword storage

vocabulary_storage = {}
qa_storage = {}

Mechanismen voor invoervalidatie en uitgebreide foutbehandeling.

Nu is het tijd om de applicatie uit te voeren.

Om de applicatie in de ontwikkelingsmodus te kunnen draaien, moeten we FasyAPI CLI gebruiken. Deze wordt samen met FastAPI geïnstalleerd.
Typ de code in uw terminal in de hoofdmap van de toepassing.

$ fastapi dev main.py

Output:

Als u dan CTRL + Rechtsklikt op de link http://127.0.0.1:8000 U krijgt een welkomstscherm in de webbrowser.

Om naar de documentatiepagina van FastAPI te gaan, klikt u gewoon op de volgende URL of typt u http://127.0.0.1:8000/docs in uw browser en u ziet alle HTTP-methoden op de pagina om te testen.

Om de API te testen, klikt u op een van de POST-methoden en PROBEER HET UIT, zet de tekst die u wilt in het invoerveld en voer het uit. U krijgt het antwoord op basis van de services, zoals vocabulaire en vraagantwoord.

Voer uit:

Reactie:

Voer uit:

Reactie:

Get-methoden testen

Haal woordenschat uit de opslag.

Voer uit:

Plaats dezelfde tekst als in de POST-methode in het invoerveld.

Reactie:

U krijgt de onderstaande uitvoer van de opslag.

en ook voor vraag-en-antwoord

Voer uit:

Reactie:

Dat zal een volledig draaiende webserver-API zijn voor docenten Engels met behulp van Google Gemini AI.

Verdere ontwikkelingsmogelijkheden

De huidige implementatie opent de deur naar interessante toekomstige verbeteringen:

• Ontdek oplossingen voor permanente opslag om gegevens effectief te bewaren tussen sessies.
• Integreer robuuste authenticatiemechanismen voor verbeterde beveiliging.
• Geavanceerde tekstanalysemogelijkheden met geavanceerdere functies.
• Ontwerp en bouw een intuïtieve front-endinterface voor betere gebruikersinteractie.
• Implementeer efficiënte snelheidsbeperkings- en cachestrategieën om de prestaties te optimaliseren.

Praktische overwegingen en beperkingen

Hoewel onze API krachtige mogelijkheden biedt, moet u rekening houden met het volgende:

• Houd bij het plannen van het gebruik rekening met de kosten voor API-gebruik en snelheidslimieten om onverwachte kosten te voorkomen en schaalbaarheid te garanderen.
• Houd rekening met de verwerkingstijd van complexe teksten, aangezien langere of ingewikkelde invoer kan resulteren in langere reactietijden.
• Houd er rekening mee dat Google voortdurend updates voor uw model uitvoert. Deze kunnen op termijn van invloed zijn op de prestaties of mogelijkheden van de API.
• Houd er rekening mee dat door AI gegenereerde reacties kunnen variëren. Daarom is het belangrijk om rekening te houden met mogelijke inconsistenties in de uitvoerkwaliteit.

Conclusie

We hebben een flexibele, intelligente API gecreëerd die tekstuele analyse transformeert door de synergie van Google Gemini, FastAPI en Pydantic. Deze oplossing laat zien hoe moderne AI-technologieën kunnen worden ingezet om diepe, betekenisvolle inzichten uit tekstuele data te halen.

Je kunt alle code van het project in de CODE-OPSLAG.

Key Takeaways

• API's met AI kunnen intelligente, contextbewuste tekstanalyses bieden.
• FastAPI vereenvoudigt complexe API-ontwikkeling met automatische documentatie.
• Met de English Educator App API kunnen ontwikkelaars interactieve en gepersonaliseerde taalleerervaringen creëren.
• Door de API van de English Educator App te integreren, kunt u de levering van content stroomlijnen en zowel de onderwijsresultaten als de betrokkenheid van gebruikers verbeteren.

Veelgestelde vragen

De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt.

Een autodidact, projectgedreven leerling, werk graag aan complexe projecten over deep learning, computer vision en NLP. Ik probeer altijd een diepgaand begrip te krijgen van het onderwerp, dat zich op elk gebied kan bevinden, zoals deep learning, machine learning of natuurkunde. Ik maak graag content over mijn leerproces. Probeer mijn begrip te delen met de wereld.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
• Bron: https://www.analyticsvidhya.com/blog/2024/12/english-educator-app-api/