วิธีเข้าถึง Gemini 3.1 Flash Lite API

Gemini 3.1 Flash Lite ของ Google เปิดตัวเมื่อวันที่ 3 มีนาคม 2026 และเป็นโมเดลที่เร็วที่สุดและประหยัดที่สุดในกลุ่มผลิตภัณฑ์ Gemini ด้วยราคา $0.25 ต่อโทเค็นอินพุตหนึ่งล้านโทเค็น และ $1.50 ต่อโทเค็นเอาต์พุตหนึ่งล้านโทเค็น โมเดลนี้ถูกสร้างขึ้นสำหรับนักพัฒนาที่ต้องการ AI ในวงกว้างโดยไม่ใช้งบประมาณมากเกินไป

คู่มือนี้จะแสดงให้คุณเห็นถึงวิธีเข้าถึง, ตั้งค่า API key, และเริ่มสร้างคำขอ คุณจะมีโค้ดที่ใช้งานได้ภายใน 10 นาที

สรุป

การตั้งค่าด่วน:

ไปที่ Google AI Studio
สร้างโปรเจกต์และสร้าง API key
ติดตั้ง SDK: pip install google-generativeai
สร้างคำขอแรกของคุณด้วยโมเดล gemini-3.1-flash-lite
ทดสอบใน Apidog เพื่อการดีบักที่ง่ายขึ้นและการทำงานร่วมกันเป็นทีม

ราคา: $0.25/โทเค็นอินพุต 1M, $1.50/โทเค็นเอาต์พุต 1M
ความเร็ว: เร็วขึ้น 2.5 เท่าเมื่อเทียบกับ Gemini 2.5 Flash
ระดับฟรี: โทเค็นอินพุต 1 ล้านโทเค็นฟรีในช่วงพรีวิว

Gemini 3.1 Flash Lite คืออะไร?

Gemini 3.1 Flash Lite คือโมเดล AI ใหม่ล่าสุดของ Google ที่ออกแบบมาสำหรับแอปพลิเคชันที่มีปริมาณงานสูง มันเร็วกว่า Gemini 2.5 Flash ถึง 2.5 เท่า ด้วยความเร็วเอาต์พุตที่เร็วขึ้น 45% ขณะที่ได้คะแนน 86.9% ใน GPQA Diamond และ 76.8% ในเกณฑ์มาตรฐาน MMMU Pro

โมเดลนี้มีระดับการคิดที่คุณสามารถปรับได้ตามคำขอ ลดระดับลงสำหรับงานง่ายๆ เพิ่มระดับขึ้นสำหรับการให้เหตุผลที่ซับซ้อน ความยืดหยุ่นนี้ช่วยให้คุณสามารถเพิ่มประสิทธิภาพต้นทุนในขณะที่จัดการปริมาณงานที่หลากหลายได้

สามารถใช้งานได้ผ่าน Google AI Studio สำหรับนักพัฒนาแต่ละราย และ Vertex AI สำหรับองค์กร

ข้อกำหนดเบื้องต้น

ก่อนที่คุณจะเริ่ม ตรวจสอบให้แน่ใจว่าคุณมีสิ่งเหล่านี้:

บัญชี Google
ติดตั้ง Python 3.7+ หรือ Node.js 14+ แล้ว
ความเข้าใจพื้นฐานเกี่ยวกับ REST API
(ไม่บังคับ) ติดตั้ง Apidog สำหรับการทดสอบ API

ขั้นตอนที่ 1: สร้างบัญชี Google AI Studio

Google AI Studio เป็นวิธีที่เร็วที่สุดในการเข้าถึงโมเดล Gemini สำหรับการพัฒนา

ไปที่ aistudio.google.com
ลงชื่อเข้าใช้ด้วยบัญชี Google ของคุณ
ยอมรับข้อกำหนดในการให้บริการ
คุณจะเข้าสู่แดชบอร์ด AI Studio

อินเทอร์เฟซจะแสดงโมเดลที่ใช้งานได้, การใช้งาน API ของคุณ, และเทมเพลตเริ่มต้นอย่างรวดเร็ว Flash Lite จะปรากฏในรายการดร็อปดาวน์โมเดลเป็น gemini-3.1-flash-lite

ขั้นตอนที่ 2: สร้าง API Key ของคุณ

API key ช่วยให้คุณยืนยันตัวตนคำขอไปยัง Gemini API

คลิก รับ API Key ที่มุมขวาบน
เลือก สร้าง API key ในโปรเจกต์ใหม่ (หรือเลือกโปรเจกต์ที่มีอยู่)
Google จะสร้างโปรเจกต์ Cloud ใหม่และสร้าง key ของคุณ
คัดลอก API key - มันมีลักษณะเหมือน AIzaSyXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
จัดเก็บอย่างปลอดภัย - คุณจะไม่เห็นมันอีก

เคล็ดลับความปลอดภัย: อย่าผูก API key กับระบบควบคุมเวอร์ชัน ใช้ตัวแปรสภาพแวดล้อมหรือเครื่องมือจัดการความลับ

ขั้นตอนที่ 3: ติดตั้ง SDK

Google มี SDK อย่างเป็นทางการสำหรับ Python และ Node.js

Python

pip install google-generativeai

Node.js

npm install @google/generative-ai

SDK จัดการการยืนยันตัวตน, การจัดรูปแบบคำขอ, และการแยกวิเคราะห์การตอบสนอง คุณยังสามารถใช้ REST API โดยตรงได้หากต้องการ

ขั้นตอนที่ 4: สร้างคำขอแรกของคุณ

มาส่งพรอมต์ง่ายๆ ไปยัง Flash Lite กัน

ตัวอย่าง Python

import google.generativeai as genai
import os

# กำหนดค่า API key
genai.configure(api_key=os.environ.get('GOOGLE_API_KEY'))

# กำหนดค่าเริ่มต้นโมเดล
model = genai.GenerativeModel('gemini-3.1-flash-lite')

# สร้างเนื้อหา
response = model.generate_content('อธิบาย REST API ในประโยคเดียว')

print(response.text)

ตัวอย่าง Node.js

const { GoogleGenerativeAI } = require("@google/generative-ai");

// กำหนดค่าเริ่มต้นด้วย API key
const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY);

async function run() {
  // รับโมเดล
  const model = genAI.getGenerativeModel({ model: "gemini-3.1-flash-lite" });

  // สร้างเนื้อหา
  const result = await model.generateContent("อธิบาย REST API ในประโยคเดียว");
  const response = await result.response;
  const text = response.text();

  console.log(text);
}

run();

ตัวอย่าง cURL (REST API)

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-flash-lite:generateContent?key=YOUR_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "contents": [{
      "parts": [{
        "text": "อธิบาย REST API ในประโยคเดียว"
      }]
    }]
  }'

เรียกใช้ตัวอย่างใดก็ได้เหล่านี้ แล้วคุณจะได้รับการตอบสนองภายในไม่กี่วินาที โมเดลจะส่งคืนข้อความที่ชัดเจนและกระชับซึ่งตอบพรอมต์ของคุณ

ขั้นตอนที่ 5: ทดสอบด้วย Apidog

Apidog ทำให้การทดสอบ API ง่ายขึ้นด้วยอินเทอร์เฟซแบบกราฟิก, การทำงานร่วมกันเป็นทีม, และเอกสารอัตโนมัติ

ทำไมต้องใช้ Apidog สำหรับ Gemini API?

ตัวสร้างคำขอแบบกราฟิก - ไม่จำเป็นต้องเขียนคำสั่ง cURL
ตัวแปรสภาพแวดล้อม - สลับระหว่าง API key สำหรับการพัฒนา/การผลิตได้อย่างง่ายดาย
การตรวจสอบการตอบสนอง - ดักจับข้อผิดพลาดก่อนที่จะเข้าสู่การผลิต
การแบ่งปันกับทีม - แบ่งปันคอลเลกชัน API กับทีมของคุณ
เอกสารอัตโนมัติ - สร้างเอกสารจากคำขอของคุณ

คุณจะเห็นการตอบสนองในแผงด้านขวาพร้อมการเน้นไวยากรณ์, เวลาตอบสนอง, และรหัสสถานะ

บันทึกเป็นตัวแปรสภาพแวดล้อม

ไปที่ Environments ใน Apidog
สร้างสภาพแวดล้อมใหม่ (เช่น "Gemini Dev")
เพิ่มตัวแปร: GOOGLE_API_KEY = API key จริงของคุณ
ใช้ {{GOOGLE_API_KEY}} ในคำขอของคุณ

ตอนนี้คุณสามารถสลับสภาพแวดล้อมได้โดยไม่ต้องเปลี่ยนคำขอของคุณ เหมาะสำหรับการจัดการ key สำหรับการพัฒนา, การทดสอบ, และการผลิต

ทำความเข้าใจรูปแบบคำขอ

Gemini API ใช้โครงสร้าง JSON เฉพาะ

โครงสร้างคำขอพื้นฐาน

{
  "contents": [{
    "parts": [{
      "text": "พรอมต์ของคุณที่นี่"
    }]
  }]
}

ด้วยระดับการคิด

{
  "contents": [{
    "parts": [{
      "text": "สร้างเอกสาร API สำหรับเอนด์พอยต์การยืนยันตัวตนผู้ใช้"
    }]
  }],
  "generationConfig": {
    "thinkingLevel": "high"
  }
}

ระดับการคิด: low, medium, high

ต่ำ: การตอบสนองที่รวดเร็วและง่ายดาย
ปานกลาง: การให้เหตุผลที่สมดุล
สูง: การวิเคราะห์เชิงลึก, งานที่ซับซ้อน

ด้วยคำแนะนำระบบ

{
  "systemInstruction": {
    "parts": [{
      "text": "คุณคือผู้เชี่ยวชาญด้านเอกสาร API เขียนเอกสารที่ชัดเจนและกระชับ"
    }]
  },
  "contents": [{
    "parts": [{
      "text": "สร้างเอกสารสำหรับเอนด์พอยต์นี้: POST /api/users"
    }]
  }]
}

คำแนะนำระบบจะชี้นำพฤติกรรมของโมเดลตลอดทุกคำขอในการสนทนา

รูปแบบการตอบสนอง

API จะส่งคืน JSON ที่มีโครงสร้างนี้:

{
  "candidates": [{
    "content": {
      "parts": [{
        "text": "REST API คืออินเทอร์เฟซที่ช่วยให้แอปพลิเคชันสื่อสารผ่าน HTTP โดยใช้วิธีการมาตรฐาน เช่น GET, POST, PUT และ DELETE"
      }],
      "role": "model"
    },
    "finishReason": "STOP",
    "index": 0,
    "safetyRatings": [...]
  }],
  "usageMetadata": {
    "promptTokenCount": 8,
    "candidatesTokenCount": 25,
    "totalTokenCount": 33
  }
}

ฟิลด์สำคัญ:

candidates[0].content.parts[0].text - การตอบสนองที่สร้างขึ้น
usageMetadata - จำนวนโทเค็นสำหรับการเรียกเก็บเงิน
finishReason - เหตุผลที่การสร้างหยุดลง (STOP, MAX_TOKENS, SAFETY)

กรณีการใช้งานทั่วไป

1. การสร้างเอกสาร API

import google.generativeai as genai

genai.configure(api_key=os.environ.get('GOOGLE_API_KEY'))
model = genai.GenerativeModel('gemini-3.1-flash-lite')

endpoint_spec = """
POST /api/v1/users
สร้างบัญชีผู้ใช้ใหม่
Body: { "email": string, "password": string, "name": string }
"""

response = model.generate_content(
    f"สร้างเอกสาร API ที่ครอบคลุมสำหรับเอนด์พอยต์นี้:\n{endpoint_spec}",
    generation_config={"thinkingLevel": "medium"}
)

print(response.text)

2. การตรวจสอบคำขอ

def validate_api_request(request_body):
    model = genai.GenerativeModel('gemini-3.1-flash-lite')

    prompt = f"""
    ตรวจสอบเนื้อหาคำขอ API นี้และแสดงรายการปัญหาใดๆ:
    {request_body}

    ตรวจสอบสำหรับ:
    - ฟิลด์ที่จำเป็นขาดหายไป
    - ประเภทข้อมูลไม่ถูกต้อง
    - ข้อกังวลด้านความปลอดภัย
    """

    response = model.generate_content(prompt)
    return response.text

# ตัวอย่างการใช้งาน
request = '{"email": "test@example.com", "password": "123"}'
validation_result = validate_api_request(request)
print(validation_result)

3. การสร้างข้อความแสดงข้อผิดพลาด

def generate_user_friendly_error(error_code, technical_message):
    model = genai.GenerativeModel('gemini-3.1-flash-lite')

    prompt = f"""
    แปลงข้อผิดพลาดทางเทคนิคนี้ให้เป็นข้อความที่ผู้ใช้เข้าใจง่าย:
    รหัสข้อผิดพลาด: {error_code}
    ทางเทคนิค: {technical_message}

    ทำให้ชัดเจน, สามารถดำเนินการได้, และไม่ใช่ศัพท์เทคนิค
    """

    response = model.generate_content(
        prompt,
        generation_config={"thinkingLevel": "low"}
    )
    return response.text

# ตัวอย่าง
friendly_error = generate_user_friendly_error(
    "AUTH_TOKEN_EXPIRED",
    "การตรวจสอบ JWT token ล้มเหลว: 'exp' claim อยู่ในอดีต"
)
print(friendly_error)

ขีดจำกัดอัตราและโควตา

Flash Lite มีขีดจำกัดที่กว้างขวางในช่วงพรีวิว:

ระดับฟรี:

โทเค็นอินพุต 1 ล้านโทเค็นฟรี
15 คำขอต่อนาที
1,500 คำขอต่อวัน

ระดับเสียเงิน:

$0.25 ต่อโทเค็นอินพุต 1 ล้านโทเค็น
$1.50 ต่อโทเค็นเอาต์พุต 1 ล้านโทเค็น
60 คำขอต่อนาที
ไม่มีขีดจำกัดรายวัน

ตรวจสอบการใช้งานของคุณใน Google AI Studio ภายใต้ Usage & Billing

การจัดการข้อผิดพลาด

จัดการข้อผิดพลาดทั่วไปอย่างนุ่มนวล:

import google.generativeai as genai
from google.api_core import exceptions

genai.configure(api_key=os.environ.get('GOOGLE_API_KEY'))
model = genai.GenerativeModel('gemini-3.1-flash-lite')

def safe_generate(prompt):
    try:
        response = model.generate_content(prompt)
        return response.text
    except exceptions.ResourceExhausted:
        return "เกินขีดจำกัดอัตรา โปรดลองอีกครั้งในหนึ่งนาที"
    except exceptions.InvalidArgument as e:
        return f"คำขอไม่ถูกต้อง: {str(e)}"
    except exceptions.PermissionDenied:
        return "API key ไม่ถูกต้องหรือหมดอายุ"
    except Exception as e:
        return f"ข้อผิดพลาดที่ไม่คาดคิด: {str(e)}"

result = safe_generate("อธิบาย API")
print(result)

ข้อผิดพลาดทั่วไป:

400 Bad Request - JSON ไม่ถูกต้องหรือฟิลด์ที่จำเป็นขาดหายไป
401 Unauthorized - API key ไม่ถูกต้อง
429 Too Many Requests - เกินขีดจำกัดอัตรา
500 Internal Server Error - เซิร์ฟเวอร์ของ Google มีปัญหา

การแก้ไขปัญหา

"API key ไม่ถูกต้อง"

ตรวจสอบสิ่งเหล่านี้:

คัดลอก API key ถูกต้องแล้ว (ไม่มีช่องว่างเพิ่มเติม)
เปิดใช้งาน API key ใน Google Cloud Console แล้ว
เปิดใช้งานการเรียกเก็บเงินในโปรเจกต์ของคุณแล้ว
ใช้ชื่อตัวแปรสภาพแวดล้อมที่ถูกต้อง

"ไม่พบโมเดล"

ตรวจสอบให้แน่ใจว่าคุณใช้ชื่อโมเดลที่ถูกต้อง:

# ถูกต้อง
model = genai.GenerativeModel('gemini-3.1-flash-lite')

# ผิด
model = genai.GenerativeModel('gemini-flash-lite')
model = genai.GenerativeModel('gemini-3.1-flash')

"เกินขีดจำกัดอัตรา"

คุณถึงขีดจำกัดคำขอต่อนาที วิธีแก้ไข:

เพิ่มตรรกะการลองใหม่แบบ exponential backoff
รวมพรอมต์หลายรายการเข้าเป็นคำขอเดียว
อัปเกรดเป็นระดับเสียเงินเพื่อขีดจำกัดที่สูงขึ้น
ใช้การจัดคิวคำขอ

การตอบสนองช้า

Flash Lite นั้นเร็ว แต่ถ้าคุณเห็นความล่าช้า:

ตรวจสอบการเชื่อมต่อเครือข่ายของคุณ
ใช้ระดับการคิดที่ต่ำกว่าสำหรับงานง่ายๆ
ลดความยาวของพรอมต์
พิจารณาการสตรีมการตอบสนองสำหรับเอาต์พุตที่ยาว

ขั้นสูง: การสตรีมการตอบสนอง

สำหรับเอาต์พุตที่ยาว ให้สตรีมโทเค็นขณะที่สร้างขึ้น:

import google.generativeai as genai

genai.configure(api_key=os.environ.get('GOOGLE_API_KEY'))
model = genai.GenerativeModel('gemini-3.1-flash-lite')

prompt = "เขียนคำอธิบายโดยละเอียดเกี่ยวกับวิธีการยืนยันตัวตน REST API"

response = model.generate_content(prompt, stream=True)

for chunk in response:
    print(chunk.text, end='', flush=True)

การสตรีมช่วยเพิ่มประสิทธิภาพที่รับรู้ ผู้ใช้เห็นเอาต์พุตทันทีแทนที่จะรอการตอบสนองที่สมบูรณ์

เคล็ดลับการเพิ่มประสิทธิภาพต้นทุน

1. รวมคำขอที่คล้ายกัน

# แพง: 3 คำขอแยกกัน
response1 = model.generate_content("อธิบาย GET")
response2 = model.generate_content("อธิบาย POST")
response3 = model.generate_content("อธิบาย PUT")

# ถูกกว่า: 1 คำขอรวม
combined_prompt = """
อธิบายวิธีการ HTTP เหล่านี้:
1. GET
2. POST
3. PUT
"""
response = model.generate_content(combined_prompt)

2. ใช้ระดับการคิดที่ต่ำกว่า

# สำหรับการจัดหมวดหมู่แบบง่าย
response = model.generate_content(
    "อีเมลนี้เป็นสแปมหรือไม่? 'ซื้อตอนนี้!'",
    generation_config={"thinkingLevel": "low"}
)

# สำหรับการวิเคราะห์ที่ซับซ้อน
response = model.generate_content(
    "วิเคราะห์การออกแบบ API นี้และแนะนำการปรับปรุง...",
    generation_config={"thinkingLevel": "high"}
)

3. ใช้การแคช

แคชการตอบสนองสำหรับคำถามที่ซ้ำกัน การแคชในหน่วยความจำแบบง่ายสามารถลดต้นทุนได้มากกว่า 50% สำหรับคำขอทั่วไป

4. ตัดพรอมต์ให้สั้นลง

ลบบริบทที่ไม่จำเป็น:

# ละเอียด (โทเค็นมากขึ้น)
prompt = "ฉันต้องการให้คุณช่วยอธิบาย REST API คืออะไรและทำงานอย่างไรโดยละเอียด"

# กระชับ (โทเค็นน้อยลง)
prompt = "อธิบาย REST API"

ข้อควรพิจารณาด้านความปลอดภัย

1. ปกป้อง API Key ของคุณ

จัดเก็บในตัวแปรสภาพแวดล้อมหรือตัวจัดการความลับ
หมุนเวียน key เป็นประจำ
ใช้ key แยกกันสำหรับการพัฒนา/การทดสอบ/การผลิต
อย่าบันทึก API key

2. ตรวจสอบอินพุตผู้ใช้

def safe_prompt(user_input):
    # ลบความพยายามในการฉีดข้อมูลที่เป็นไปได้
    cleaned = user_input.replace("ละเว้นคำแนะนำก่อนหน้านี้", "")
    cleaned = cleaned[:1000]  # จำกัดความยาว

    return f"คำถามผู้ใช้: {cleaned}"

3. กรองข้อมูลที่ละเอียดอ่อน

อย่าส่งข้อมูลที่ละเอียดอ่อนไปยัง API:

import re

def sanitize_for_ai(text):
    # ลบที่อยู่อีเมล
    text = re.sub(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', '[อีเมล]', text)
    # ลบเบอร์โทรศัพท์
    text = re.sub(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', '[เบอร์โทรศัพท์]', text)
    # ลบบัตรเครดิต
    text = re.sub(r'\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b', '[บัตร]', text)
    return text

4. ใช้การจำกัดอัตรา

ปกป้อง API key ของคุณจากการนำไปใช้ในทางที่ผิด:

from collections import defaultdict
import time

class RateLimiter:
    def __init__(self, max_requests=10, window=60):
        self.max_requests = max_requests
        self.window = window
        self.requests = defaultdict(list)

    def allow_request(self, user_id):
        now = time.time()
        # ลบคำขอเก่า
        self.requests[user_id] = [
            req_time for req_time in self.requests[user_id]
            if now - req_time < self.window
        ]

        if len(self.requests[user_id]) < self.max_requests:
            self.requests[user_id].append(now)
            return True
        return False

limiter = RateLimiter(max_requests=10, window=60)

def generate_with_limit(user_id, prompt):
    if not limiter.allow_request(user_id):
        return "เกินขีดจำกัดอัตรา โปรดลองอีกครั้งในภายหลัง"

    model = genai.GenerativeModel('gemini-3.1-flash-lite')
    response = model.generate_content(prompt)
    return response.text

เปรียบเทียบ Flash Lite กับโมเดล Gemini อื่นๆ

คุณสมบัติ	Flash Lite	Flash	Pro
ราคาอินพุต	$0.25/1M	$0.50/1M	$1.25/1M
ราคาเอาต์พุต	$1.50/1M	$3.00/1M	$7.50/1M
ความเร็ว	เร็วขึ้น 2.5 เท่า	เร็ว	มาตรฐาน
ขนาดบริบท	32K โทเค็น	1M โทเค็น	2M โทเค็น
เหมาะสำหรับ	ปริมาณงานสูง, คำนึงถึงต้นทุน	สมดุล	การให้เหตุผลที่ซับซ้อน

เลือก Flash Lite เมื่อ:

คุณต้องการการตอบสนองที่รวดเร็ว
ต้นทุนเป็นสิ่งสำคัญ
คำขอน้อยกว่า 32K โทเค็น
ความต้องการด้านคุณภาพอยู่ในระดับปานกลาง

เลือก Flash เมื่อ:

คุณต้องการขนาดบริบทที่ใหญ่
คุณภาพสำคัญกว่าต้นทุน

เลือก Pro เมื่อ:

คุณต้องการความสามารถในการให้เหตุผลสูงสุด
ต้นทุนไม่ใช่ข้อกังวล
ทำงานกับเอกสารขนาดใหญ่มาก

การผสานรวมกับ Apidog Workflows

ผู้ใช้ Apidog สามารถผสานรวม Flash Lite เข้ากับขั้นตอนการทำงานการพัฒนา API ของพวกเขาได้:

1. สร้างกรณีทดสอบอัตโนมัติ

ใช้ Flash Lite เพื่อสร้างกรณีทดสอบจากข้อกำหนด API ของคุณ:

def generate_test_cases(endpoint_spec):
    model = genai.GenerativeModel('gemini-3.1-flash-lite')

    prompt = f"""
    สร้างกรณีทดสอบที่ครอบคลุมสำหรับเอนด์พอยต์ API นี้:
    {json.dumps(endpoint_spec, indent=2)}

    รวมถึง:
    - การทดสอบ Happy path
    - กรณีขอบ
    - สถานการณ์ข้อผิดพลาด
    - เงื่อนไขขอบเขต

    จัดรูปแบบเป็นอาร์เรย์ JSON ของกรณีทดสอบ
    """

    response = model.generate_content(prompt)
    return json.loads(response.text)

2. ตรวจสอบการตอบสนองของ API

ตรวจสอบว่าการตอบสนองตรงกับสคีมาที่คาดไว้หรือไม่:

def validate_response(response_data, expected_schema):
    model = genai.GenerativeModel('gemini-3.1-flash-lite')

    prompt = f"""
    ตรวจสอบการตอบสนอง API นี้เทียบกับสคีมา:

    การตอบสนอง: {json.dumps(response_data, indent=2)}
    สคีมา: {json.dumps(expected_schema, indent=2)}

    แสดงรายการความไม่ตรงกันหรือปัญหาใดๆ
    """

    response = model.generate_content(
        prompt,
        generation_config={"thinkingLevel": "low"}
    )
    return response.text

3. สร้างข้อมูลจำลอง

สร้างข้อมูลทดสอบที่สมจริง:

def generate_mock_data(schema, count=10):
    model = genai.GenerativeModel('gemini-3.1-flash-lite')

    prompt = f"""
    สร้างข้อมูลจำลองที่สมจริง {count} รายการที่ตรงกับสคีมานี้:
    {json.dumps(schema, indent=2)}

    ส่งคืนเป็นอาร์เรย์ JSON
    """

    response = model.generate_content(prompt)
    return json.loads(response.text)

คำถามที่พบบ่อย

Gemini 3.1 Flash Lite ฟรีหรือไม่?

โทเค็นอินพุต 1 ล้านโทเค็นแรกฟรีในช่วงพรีวิว หลังจากนั้น คุณจะต้องจ่าย $0.25 ต่อโทเค็นอินพุตหนึ่งล้านโทเค็น และ $1.50 ต่อโทเค็นเอาต์พุตหนึ่งล้านโทเค็น

Flash Lite เร็วแค่ไหนเมื่อเทียบกับโมเดลอื่น?

Flash Lite เร็วกว่า Gemini 2.5 Flash ถึง 2.5 เท่าสำหรับเวลาถึงโทเค็นแรก และเร็วขึ้น 45% สำหรับความเร็วเอาต์พุต เป็นหนึ่งในโมเดลที่เร็วที่สุดที่มีอยู่

ฉันสามารถใช้ Flash Lite ในการผลิตได้หรือไม่?

ได้ แม้ว่าจะติดป้ายว่าเป็น "พรีวิว" แต่โมเดลก็มีความเสถียรเพียงพอสำหรับการใช้งานจริง ผู้ใช้งานกลุ่มแรกอย่าง Latitude, Cartwheel และ Whering กำลังใช้งานอยู่แล้วในวงกว้าง

ขนาดบริบทคือเท่าไร?

Flash Lite รองรับบริบทสูงสุด 32,000 โทเค็น ซึ่งเพียงพอสำหรับกรณีการใช้งาน API ส่วนใหญ่ แต่เล็กกว่า Flash (1 ล้านโทเค็น) หรือ Pro (2 ล้านโทเค็น)

ระดับการคิดทำงานอย่างไร?

ระดับการคิดควบคุมปริมาณการประมวลผลที่โมเดลใช้ ระดับต่ำนั้นเร็วและง่าย ระดับสูงนั้นช้ากว่าแต่ละเอียดกว่า ใช้ระดับต่ำสำหรับการจัดหมวดหมู่, ระดับสูงสำหรับการให้เหตุผลที่ซับซ้อน

ฉันสามารถใช้ Flash Lite กับ Apidog ได้หรือไม่?

ได้ Apidog ทำงานร่วมกับ REST API ใดก็ได้ รวมถึง Gemini ตั้งค่าคำขอของคุณใน Apidog เพื่อการทดสอบที่ง่ายขึ้น, การทำงานร่วมกันเป็นทีม, และการสร้างเอกสาร

จะเกิดอะไรขึ้นถ้าฉันเกินขีดจำกัดอัตรา?

คุณจะได้รับข้อผิดพลาด 429 ใช้ตรรกะการลองใหม่แบบ exponential backoff หรืออัปเกรดเป็นระดับเสียเงินเพื่อขีดจำกัดที่สูงขึ้น (60 คำขอ/นาที เทียบกับ 15)

ข้อมูลของฉันถูกใช้ในการฝึกโมเดลหรือไม่?

ตามนโยบายของ Google คำขอ API จะไม่ถูกใช้ในการฝึกโมเดล ข้อมูลของคุณยังคงเป็นส่วนตัว

ฉันสามารถปรับแต่ง Flash Lite ได้หรือไม่?

ยังไม่ได้ การปรับแต่งมีให้ใช้งานสำหรับโมเดล Gemini บางรุ่น แต่ไม่ใช่ Flash Lite ในตอนเปิดตัว ใช้คำแนะนำระบบเพื่อชี้นำพฤติกรรมแทน

Flash Lite เปรียบเทียบกับ GPT-4 Turbo อย่างไร?

Flash Lite เร็วและถูกกว่า แต่ GPT-4 Turbo มีการให้เหตุผลที่แข็งแกร่งกว่าสำหรับงานที่ซับซ้อน สำหรับปริมาณงาน API ที่สูง Flash Lite ชนะเรื่องต้นทุนและความเร็ว

ขั้นตอนต่อไป

ตอนนี้คุณมีทุกสิ่งที่จำเป็นในการเริ่มใช้ Gemini 3.1 Flash Lite แล้ว:

รับ API key ของคุณ จาก Google AI Studio
ติดตั้ง SDK และเรียกใช้คำขอแรกของคุณ
ทดสอบใน Apidog เพื่อการพัฒนาที่ง่ายขึ้น
ใช้การจัดการข้อผิดพลาด และตรรกะการลองใหม่
ตรวจสอบการใช้งาน เพื่อเพิ่มประสิทธิภาพต้นทุน

โมเดลพร้อมสำหรับการใช้งานจริง ราคาทำให้ AI เข้าถึงได้ในวงกว้าง ความเร็วทำให้ผู้ใช้ของคุณพึงพอใจ

เริ่มสร้างได้เลย

ปุ่ม