วิธีใช้ Gemini 3.1 Pro API อย่างละเอียด

Google ได้เปิดตัว Gemini 3.1 Pro ซึ่งเป็นโมเดลที่มีความสามารถสูงสุดเท่าที่เคยมีมา วิศวกรสามารถเข้าถึงโมเดลพรีวิวนี้ผ่าน Gemini API เพื่อจัดการกับการให้เหตุผลที่ซับซ้อน การทำความเข้าใจแบบหลายโมดอล และเวิร์กโฟลว์แบบเอเจนซี่ ซึ่งโมเดลรุ่นก่อนๆ จัดการได้ไม่ค่อยมีประสิทธิภาพ นักพัฒนาที่รวม Gemini 3.1 Pro API จะได้รับประสิทธิภาพที่ล้ำสมัยด้วยอินพุตโทเค็นสูงสุด 1 ล้านโทเค็นและเอาต์พุต 64k โทเค็น พร้อมรักษาความหน่วงต่ำสำหรับระบบการผลิต

คุณเริ่มต้นการเดินทางด้วยตัวระบุโมเดลอย่างเป็นทางการ gemini-3.1-pro-preview Google โฮสต์เอนด์พอยต์นี้ที่ https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-pro-preview:generateContent API รองรับทั้งการเรียกใช้ REST และ SDK อย่างเป็นทางการที่ช่วยลดความซับซ้อนในขณะที่ยังคงควบคุมได้เต็มที่

ทำความเข้าใจ Gemini 3.1 Pro: ความสามารถที่กำหนดนิยามใหม่ของการผสานรวม AI

Gemini 3.1 Pro พัฒนาไปไกลกว่าโมเดลรุ่นก่อนๆ ด้วยการคิดแบบไดนามิกแบบเนทีฟ การใช้เครื่องมือที่ได้รับการปรับปรุง และการหลอมรวมหลายโมดอลที่เหนือกว่า โมเดลประมวลผลข้อความ รูปภาพความละเอียดสูง เฟรมวิดีโอ ไฟล์ PDF สูงสุด 1,000 หน้า และโค้ดพร้อมกันภายในหน้าต่างบริบทเดียวกัน ด้วยเหตุนี้ วิศวกรจึงสามารถบรรลุการให้เหตุผลแบบหลายขั้นตอนที่สอดคล้องกันมากขึ้นโดยไม่ต้องมีการปรับแต่งพรอมต์ที่ซับซ้อน

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

นอกจากนี้ Gemini 3.1 Pro ยังรองรับลายเซ็นความคิด (thought signatures) สตริงที่เข้ารหัสเหล่านี้จะรักษาสถานะการสนทนาข้ามรอบเมื่อคุณรวมการเรียกใช้ฟังก์ชันกับการสร้างหรือแก้ไขรูปภาพ คุณต้องใส่ค่า thoughtSignature ที่แน่นอนในการร้องขอครั้งถัดไป มิฉะนั้น API จะส่งคืนข้อผิดพลาด 400 กลไกนี้รับประกันพฤติกรรมที่คาดเดาได้ในลูปของเอเจนต์ที่ทำงานเป็นเวลานาน

จุดตัดของข้อมูล (knowledge cutoff) อยู่ที่เดือนมกราคม 2025 ดังนั้น คุณจึงจับคู่โมเดลเข้ากับเครื่องมือ Google Search ที่มีมาให้เพื่อดึงข้อมูลล่าสุด การรวมกันนี้ให้ผลลัพธ์ที่อิงความจริงและเป็นปัจจุบันโดยไม่ต้องใช้ไปป์ไลน์การสร้างแบบเสริมด้วยการดึงข้อมูลด้วยตนเอง

ข้อกำหนดเบื้องต้นสำหรับการทำงานกับ Gemini 3.1 Pro API

คุณเตรียมสภาพแวดล้อมของคุณให้พร้อมก่อนที่จะเขียนโค้ดใดๆ ประการแรก คุณต้องมีบัญชี Google ที่สามารถเข้าถึง Google AI Studio ประการที่สอง คุณต้องตรวจสอบว่าการเรียกเก็บเงินเปิดใช้งานอยู่บนโปรเจกต์ Google Cloud ที่เกี่ยวข้อง เนื่องจากโมเดลพรีวิวมีการจำกัดอัตราที่เข้มงวดสำหรับผู้ใช้ฟรี ประการที่สาม คุณติดตั้ง Python 3.9+ หรือ Node.js 18+ ขึ้นอยู่กับสแต็กที่คุณต้องการ

นอกจากนี้ คุณยังจัดสรรพื้นที่จัดเก็บสำหรับเพย์โหลดหลายโมดอลขนาดใหญ่ ไฟล์วิดีโอและรูปภาพความละเอียดสูงใช้โทเค็นอย่างรวดเร็ว ดังนั้นคุณจึงควรตรวจสอบการใช้งานผ่านแดชบอร์ด AI Studio มืออาชีพที่วางแผนล่วงหน้าจะหลีกเลี่ยงข้อผิดพลาดโควต้าที่ไม่คาดคิดระหว่างการพัฒนา

การรับและรักษาความปลอดภัยคีย์ API ของ Gemini

คุณไปที่ Google AI Studio และคลิก “รับคีย์ API” คอนโซลจะสร้างคีย์ใหม่ที่เชื่อมโยงกับโปรเจกต์ของคุณ คุณควรคัดลอกคีย์ทันทีเพราะ UI จะแสดงเพียงครั้งเดียว

คุณจัดเก็บคีย์เป็นตัวแปรสภาพแวดล้อม GEMINI_API_KEY แนวทางปฏิบัตินี้ช่วยให้ข้อมูลประจำตัวไม่อยู่ในซอร์สโค้ดและช่วยให้การเริ่มต้น SDK เป็นไปอย่างราบรื่นในระบบปฏิบัติการต่างๆ บน Linux หรือ macOS คุณรันคำสั่งนี้:

export GEMINI_API_KEY=your_actual_key_here

บน Windows คุณใช้:

set GEMINI_API_KEY=your_actual_key_here

สำหรับการปรับใช้ในการผลิต คุณควรหมุนเวียนคีย์เป็นประจำและจำกัดการเข้าถึงผ่านนโยบาย Google Cloud IAM คุณไม่ควรเปิดเผยคีย์ใน JavaScript ฝั่งไคลเอนต์ เนื่องจากผู้โจมตีสามารถใช้คีย์นั้นในทางที่ผิดเพื่อบริโภคโทเค็นโดยไม่ได้รับอนุญาต

การติดตั้ง Google GenAI SDK อย่างเป็นทางการ

SDK สรุปรายละเอียด HTTP และมีอินเทอร์เฟซที่ปลอดภัยประเภท คุณติดตั้งเวอร์ชันล่าสุดด้วยคำสั่งเหล่านี้:

Python

pip install -U google-genai

Node.js

npm install @google/genai

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

การเรียกใช้ Gemini 3.1 Pro API ครั้งแรกของคุณ

คุณเริ่มต้นไคลเอนต์และส่งพรอมต์ข้อความง่ายๆ เพื่อตรวจสอบการเชื่อมต่อ

ตัวอย่าง Python

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents="Explain the differences between Gemini 3.1 Pro and previous models in technical terms.",
    config=types.GenerateContentConfig(
        thinking_level="high"
    )
)

print(response.text)

ออบเจกต์การตอบกลับจะประกอบด้วยข้อความที่สร้างขึ้นพร้อมข้อมูลเมตาการใช้งาน คุณตรวจสอบ response.usage_metadata เพื่อติดตามการใช้โทเค็นสำหรับการเพิ่มประสิทธิภาพต้นทุน

เทียบเท่า cURL (มีประโยชน์สำหรับการทดสอบด้วย Apidog)

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-pro-preview:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -X POST \
  -d '{
    "contents": [{
      "parts": [{"text": "Explain the differences between Gemini 3.1 Pro and previous models in technical terms."}]
    }],
    "generationConfig": {
      "thinking_level": "high"
    }
  }'

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

ตัวอย่าง JavaScript

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-3.1-pro-preview",
    contents: "Explain the differences between Gemini 3.1 Pro and previous models in technical terms.",
    config: { thinking_level: "high" }
  });
  console.log(response.text);
}

main();

คุณรันสคริปต์เหล่านี้และสังเกตคำตอบที่สอดคล้องและแม่นยำทางเทคนิค โมเดลจะอ้างถึงการปรับปรุงสถาปัตยกรรม เช่น การควบคุมความละเอียดของสื่อที่ได้รับการปรับปรุงและการจัดระเบียบเครื่องมือแบบเนทีฟ

สำรวจเอนด์พอยต์หลักและโครงสร้างคำขอ

Gemini API มุ่งเน้นไปที่สามเมธอดหลัก: generateContent, streamGenerateContent และ countTokens คุณใช้ generateContent สำหรับการตอบกลับแบบซิงโครนัส และ streamGenerateContent เมื่อคุณแสดงผลลัพธ์บางส่วนให้ผู้ใช้เห็นทันที

ส่วนเนื้อหาคำขอมีโครงสร้างที่สอดคล้องกันดังนี้:

• contents: อาร์เรย์ของข้อความตามบทบาท (ผู้ใช้/โมเดล/ฟังก์ชัน)
• tools: อาร์เรย์ของการประกาศฟังก์ชัน Google Search, code_execution หรือฟังก์ชันที่กำหนดเอง
• generationConfig: ควบคุม thinking_level, temperature (คงค่าเริ่มต้น 1.0), maxOutputTokens และอื่นๆ
• safetySettings: การกำหนดค่าเพิ่มเติมสำหรับตัวกรองเนื้อหา

คุณกำหนดฟังก์ชันที่กำหนดเองด้วย JSON schemas จากนั้นโมเดลจะส่งส่วน functionCall ที่คุณดำเนินการในเครื่องและส่งคืนเป็นส่วน functionResponse ลูปปิดนี้ขับเคลื่อนเอเจนต์อิสระที่โต้ตอบกับ API ภายนอกหรือฐานข้อมูล

Apidog โดดเด่นในจุดนี้ เนื่องจากคุณสามารถนำเข้าข้อกำหนด OpenAPI หรือสร้างสคีมาด้วยตนเองได้ เครื่องมือนี้จะตรวจสอบการประกาศฟังก์ชันของคุณเทียบกับรูปแบบที่โมเดลคาดหวัง และยังจำลองการตอบกลับในระหว่างการออกแบบได้อีกด้วย

การกำหนดค่าพารามิเตอร์การสร้างเพื่อความน่าเชื่อถือในการผลิต

คุณปรับแต่งพฤติกรรมผ่านออบเจกต์ generationConfig Google แนะนำให้คงค่า temperature ไว้ที่ 1.0 เนื่องจากค่าที่ต่ำกว่าจะลดคุณภาพการให้เหตุผลในโมเดล Gemini ซีรีส์ 3 แทนที่จะเป็นเช่นนั้น คุณควรปรับ thinking_level เพื่อรักษาสมดุลระหว่างความหน่วงและระดับความลึก

พารามิเตอร์หลักได้แก่:

• thinking_level: "low" | "high" (ค่าเริ่มต้นคือ high)
• maxOutputTokens: สูงสุด 64k
• stopSequences: อาร์เรย์ของสตริงที่หยุดการสร้าง
• responseMimeType: "application/json" สำหรับเอาต์พุตที่มีโครงสร้าง
• responseJsonSchema: สคีมา Pydantic หรือ Zod สำหรับการแยกวิเคราะห์ที่ปลอดภัยต่อประเภท

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

การใช้ประโยชน์จากความสามารถหลายโมดอล

Gemini 3.1 Pro ประมวลผลรูปภาพ วิดีโอ และเอกสารแบบเนทีฟ คุณสามารถรวมข้อมูลไฟล์เป็นแบบ base64 แบบอินไลน์ หรือผ่าน File API สำหรับการอัปโหลดขนาดใหญ่

ตัวอย่าง Python แบบหลายโมดอล

import base64
from google import genai
from google.genai import types

client = genai.Client()

# Read image
with open("diagram.png", "rb") as f:
    image_bytes = f.read()

response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents=[
        types.Content(
            role="user",
            parts=[
                types.Part(text="Analyze this system architecture diagram and suggest optimizations."),
                types.Part(
                    inline_data=types.Blob(
                        mime_type="image/png",
                        data=image_bytes
                    )
                )
            ]
        )
    ],
    config=types.GenerateContentConfig(
        media_resolution="media_resolution_high"  # v1alpha endpoint if needed
    )
)

print(response.text)

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

Apidog ช่วยให้การทดสอบเหล่านี้ง่ายขึ้น คุณลากและวางไฟล์รูปภาพหรือ PDF ลงในส่วนเนื้อหาคำขอ เลือกประเภท MIME ที่ถูกต้อง และส่งคำขอได้ทันที แพลตฟอร์มจะแสดงตัวอย่างที่เรนเดอร์และช่วยให้คุณวนซ้ำพรอมต์ได้โดยไม่ต้องเขียนโค้ดใหม่

การใช้งานการเรียกฟังก์ชันและการใช้เครื่องมือ

คุณประกาศเครื่องมือในการกำหนดค่าเพื่อเปิดใช้งานพฤติกรรมแบบเอเจนต์ เครื่องมือในตัวที่รองรับได้แก่ google_search, code_execution, url_context และฟังก์ชันที่กำหนดเอง

ตัวอย่างเครื่องมือที่มีโครงสร้าง

from pydantic import BaseModel, Field
from typing import List

class WeatherData(BaseModel):
    city: str = Field(description="City name")
    temperature: float
    condition: str

response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents="Fetch current weather for Tokyo and return structured data.",
    config={
        "tools": [{"google_search": {}}],
        "response_mime_type": "application/json",
        "response_json_schema": WeatherData.model_json_schema()
    }
)

data = WeatherData.model_validate_json(response.text)
print(data)

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

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

การทดสอบและดีบักอย่างมีประสิทธิภาพด้วย Apidog

คุณเปิด Apidog และสร้างโปรเจกต์ใหม่ชื่อ “Gemini 3.1 Pro Integration” คุณเพิ่มตัวแปรส่วนกลางสำหรับคีย์ API ของคุณและตั้งค่า URL พื้นฐานเป็นเอนด์พอยต์ภาษาที่สร้างขึ้น

ถัดไป คุณสร้างคอลเลกชันสำหรับสถานการณ์ต่างๆ: ข้อความเท่านั้น, หลายโมดอล, การเรียกฟังก์ชัน และการสตรีม Apidog สร้างสคริปต์ cURL, Python และ JavaScript โดยอัตโนมัติจากคำขอที่บันทึกไว้แต่ละรายการ ด้วยเหตุนี้ คุณจึงสามารถรักษาชุดเอกสารประกอบที่ใช้งานได้ซึ่งทั้งทีมสามารถอ้างอิงได้

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

มืออาชีพที่ผสานรวม Apidog รายงานว่าวงจรการทำงานซ้ำเร็วขึ้น 40-60% เนื่องจากพวกเขาไม่ต้องสลับบริบทไปมาระหว่างโปรแกรมแก้ไขโค้ดและหน้าต่างเทอร์มินัล เวอร์ชันฟรีรองรับโปรเจกต์ภายในเครื่องไม่จำกัดและปริมาณคำขอที่เพียงพอสำหรับเวิร์กโฟลว์การพัฒนาส่วนใหญ่

เทคนิคขั้นสูง: การสตรีม, การแคชบริบท และการประมวลผลแบบแบตช์

คุณเปิดใช้งานการสตรีมสำหรับส่วนต่อประสานผู้ใช้ที่ตอบสนองได้

การสตรีมด้วย Python

response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents="Write a detailed technical specification for a new microservice.",
    stream=True
)

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

SDK จะส่งการตอบกลับบางส่วน เพื่อให้คุณแสดงข้อความได้ทันทีที่มาถึง

คุณยังใช้การแคชบริบทสำหรับเอกสารขนาดยาวที่ใช้ซ้ำได้ คุณอัปโหลด PDF ขนาด 500 หน้าเพียงครั้งเดียว แคชบริบทที่ประมวลผลแล้ว และอ้างอิง ID แคชในการเรียกใช้ครั้งถัดไป เทคนิคนี้ช่วยลดค่าใช้จ่ายโทเค็นและความหน่วงลงอย่างมากสำหรับแอปพลิเคชัน RAG ระดับองค์กร

การรองรับ Batch API ช่วยให้คุณสามารถประมวลผลพรอมต์หลายรายการได้ในการร้องขอครั้งเดียว ด้วยเหตุนี้ คุณจึงสามารถวิเคราะห์ตั๋วสนับสนุนหลายพันรายการได้ในชั่วข้ามคืน โดยยังคงอยู่ในขีดจำกัดอัตรา

กรณีการใช้งานจริงและตัวอย่างโค้ดพร้อมใช้งานสำหรับการผลิต

กรณีใช้งานที่ 1: เครื่องมือวิเคราะห์เอกสารอัจฉริยะ
คุณสร้างระบบที่นำเข้าสัญญา สกัดข้อความในสัญญา และระบุความเสี่ยง ความสามารถหลายโมดอลจะระบุตารางและลายเซ็นภายในไฟล์ PDF ที่สแกน

กรณีใช้งานที่ 2: ผู้ช่วยเขียนโค้ดอัตโนมัติ
คุณรวมเครื่องมือ code_execution เข้ากับ Gemini 3.1 Pro เพื่อดีบัก ปรับโครงสร้างใหม่ และทดสอบโค้ดในลูปเดียว โมเดลจะเขียนโค้ด Python ดำเนินการ ตรวจสอบรูปภาพเอาต์พุตหรือบันทึก และทำซ้ำจนกว่างานจะเสร็จสมบูรณ์

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

แต่ละกรณีการใช้งานจะได้รับประโยชน์จากต้นแบบ Apidog คุณออกแบบโครงสร้างเพย์โหลดที่แน่นอน ทดสอบกรณีพิเศษด้วยไฟล์ตัวอย่าง และส่งออกโค้ดพร้อมใช้งาน

แนวทางปฏิบัติที่ดีที่สุดสำหรับการควบคุมต้นทุนและประสิทธิภาพ

คุณตรวจสอบการใช้โทเค็นหลังการเรียกใช้ทุกครั้ง คุณตั้งค่า maxOutputTokens อย่างระมัดระวังและใช้เอนด์พอยต์ countTokens ก่อนการดำเนินการที่ใช้ทรัพยากรมาก คุณควรเลือกใช้ gemini-3.1-pro-preview สำหรับงานที่ซับซ้อนเท่านั้น และส่งคำค้นหาที่ง่ายกว่าไปยังรุ่นที่เบากว่าเมื่อมี

คุณใช้ exponential backoff สำหรับข้อผิดพลาดจากการจำกัดอัตรา คุณแคชการตอบกลับที่ใช้บ่อยในเครื่องหรือผ่าน Redis คุณควรตรวจสอบเอาต์พุตที่มีโครงสร้างด้วย Pydantic หรือไลบรารีที่เทียบเท่าเสมอ เพื่อตรวจจับการเปลี่ยนแปลงสคีมาตั้งแต่เนิ่นๆ

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

การแก้ไขปัญหาที่พบบ่อย

ข้อผิดพลาด 429 (ทรัพยากรหมด) จะปรากฏขึ้นเมื่อคุณใช้โควตาเกิน คุณตรวจสอบแดชบอร์ดการใช้งาน AI Studio และขอเพิ่มขีดจำกัดผ่านฝ่ายสนับสนุน Google Cloud

ข้อผิดพลาด 400 (อาร์กิวเมนต์ไม่ถูกต้อง) มักเกิดจากลายเซ็นความคิดที่ขาดหายไปในการเรียกใช้ฟังก์ชันแบบหลายรอบ คุณตรวจสอบให้แน่ใจว่าลายเซ็นการตอบกลับของโมเดลทุกรายการถูกส่งกลับไปในการร้องขอครั้งถัดไป

คำขอแบบหลายโมดอลจะล้มเหลวเมื่อขนาดไฟล์เกินขีดจำกัด คุณบีบอัดรูปภาพหรือใช้ File API สำหรับการจัดเก็บถาวร

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

การเปรียบเทียบ Gemini API กับ Vertex AI

Gemini Developer API (ai.google.dev) ให้การเริ่มต้นใช้งานที่เร็วที่สุดและเข้าถึงระดับฟรีได้ Vertex AI มีคุณสมบัติระดับองค์กร เช่น VPC Service Controls, เอนด์พอยต์ส่วนตัว และการผสานรวม IAM ที่แน่นหนาขึ้น คุณสามารถย้ายจากระบบหนึ่งไปยังอีกระบบหนึ่งได้โดยการเปลี่ยนเพียงการเริ่มต้นไคลเอนต์และเอนด์พอยต์ของโมเดลเท่านั้น รูปแบบคำขอยังคงเหมือนเดิม

ทีมส่วนใหญ่เริ่มต้นด้วย Developer API ในระหว่างการสร้างต้นแบบและย้ายไปใช้ Vertex AI ก่อนการผลิต การเปลี่ยนแปลงนี้ต้องการการแก้ไขโค้ดเพียงเล็กน้อย

สรุป

ตอนนี้คุณมีแผนงานทางเทคนิคที่สมบูรณ์สำหรับ Gemini 3.1 Pro API คุณเข้าใจความสามารถของโมเดล โฟลว์การรับรองความถูกต้อง การผสานรวม SDK การกำหนดค่าขั้นสูง อินพุตหลายโมดอล การจัดระเบียบเครื่องมือ และแนวทางปฏิบัติที่ดีที่สุดในการผลิต

การผสมผสานระหว่างพลังการให้เหตุผลของ Gemini 3.1 Pro และสภาพแวดล้อมการทดสอบด้วยภาพของ Apidog ช่วยให้คุณสามารถส่งมอบคุณสมบัติ AI ที่ซับซ้อนได้เร็วกว่าที่เคยเป็นมา คุณเริ่มต้นด้วยพรอมต์ข้อความขนาดเล็ก ขยายไปยังเอเจนต์หลายโมดอล และปรับขนาดได้อย่างมั่นใจด้วยกลยุทธ์การตรวจสอบและการแคช

สาขานี้มีการพัฒนาอย่างรวดเร็ว คุณควรบุ๊กมาร์กเอกสารทางการที่ ai.google.dev และกลับมาดูโปรเจกต์ Apidog เป็นประจำเพื่อรวมคุณสมบัติใหม่ๆ

คุณมีทุกสิ่งที่จำเป็นในการสร้างแอปพลิเคชันอัจฉริยะรุ่นต่อไป เริ่มเขียนโค้ดวันนี้ ทดสอบอย่างละเอียดด้วย Apidog และผลักดันขีดจำกัดของสิ่งที่ AI สามารถทำได้

เริ่มสร้างด้วย Gemini 3.1 Pro API ได้แล้ววันนี้ ดาวน์โหลด Apidog ฟรี และเปลี่ยนวิธีการพัฒนาและทดสอบการผสานรวม AI ของคุณ