Membina aplikasi bertenaga LLM-gred pengeluaran dengan Pydanticai

Dalam landskap pembangunan perisian yang pesat berkembang, persimpangan kecerdasan buatan, pengesahan data, dan pengurusan pangkalan data telah membuka kemungkinan yang belum pernah terjadi sebelumnya. Pos blog ini meneroka pendekatan yang inovatif untuk penjanaan kod SQL dan penjelasan kod SQL menggunakan rangka kerja Pydanticai terkini dan model Gemini-1.5 Google, menunjukkan bagaimana teknologi AI yang canggih dapat menyelaraskan dan meningkatkan pembangunan pertanyaan pangkalan data.

Bagi pemaju, saintis data, dan penganalisis data, penerokaan ini menawarkan gambaran masa depan penjanaan kod pintar dari pemprosesan bahasa semulajadi, di mana pertanyaan pangkalan data yang kompleks dapat dibuat dengan mudah dan ketepatan.

Objektif pembelajaran

• Memahami asas -asas Pydantic dan Pydanticai.
• Ketahui cara melaksanakan sistem penjanaan kod SQL yang berkuasa AI.
• Terokai keupayaan Gemini-1.5-flash dalam bahasa semulajadi untuk terjemahan SQL.
• Dapatkan wawasan untuk membina ejen AI pintar untuk interaksi pangkalan data.

Artikel ini diterbitkan sebagai sebahagian daripada Blogathon Sains Data.

Jadual Kandungan

• Apa itu Pydanticai?
• Contoh Pydanticai beraksi
• Apakah ejen AI?
• Apakah aliran kerja agentik?
• Penggunaan moden agen AI dan aliran kerja agentik
• Apakah kerangka Pydanticai?
• Bermula dengan projek anda
• Panduan Langkah demi Langkah untuk Melaksanakan Projek Anda
• Kesimpulan
• Soalan yang sering ditanya

Apa itu Pydanticai?

Pydanticai adalah perpustakaan Python yang kuat yang merevolusi pengesahan data dan pemeriksaan jenis. Ia menyediakan pendekatan deklaratif untuk menentukan model data, menjadikannya mudah untuk membuat dan mengesahkan struktur data kompleks.

Ciri -ciri penting Pydantic termasuk:

Penyesuaian

• Mengesahkan pelbagai jenis data, termasuk jenis primitif dan struktur bersarang kompleks.
• Menyokong hampir mana -mana objek python untuk pengesahan dan siriisasi

Fleksibiliti

Membolehkan kawalan ke atas ketat pengesahan data:

• Memaksa data ke jenis yang diharapkan
• Menguatkuasakan pemeriksaan jenis yang ketat apabila diperlukan

Serialization

• Menyokong penukaran lancar antara objek Pydantic, Kamus, dan JSON.
• Membolehkan API dan keserasian mendokumentasikan diri dengan alat yang menggunakan skema JSON.

Prestasi

• Logik pengesahan teras ditulis dalam karat untuk kelajuan dan kecekapan yang luar biasa.
• Sesuai untuk aplikasi tinggi seperti API REST berskala.

Ekosistem

• Digunakan secara meluas dalam perpustakaan Python yang popular seperti Fastapi, Langchain, Llamaindex, dan banyak lagi.
• LLM moden tidak boleh dilaksanakan tanpa pydantic.

Contoh Pydanticai beraksi

Pydanticai memudahkan pengesahan data dan pemeriksaan jenis dalam Python, menjadikannya alat yang berkuasa untuk membuat model data yang mantap. Mari kita meneroka beberapa contoh praktikal yang mempamerkan keupayaannya.

Pengesahan data asas

 dari basemodel import pydantic


Pengguna Kelas (BaseModel):
    Nama: Str
    Umur: Int


# Data yang sah
pengguna = pengguna (name = "Alice", umur = 30)
Cetak (pengguna)

Cetak ("===================================")
# Data tidak sah (umur adalah rentetan)
Cuba:
    Pengguna = pengguna (name = "Alice", umur = "tiga puluh")
Kecuali pengecualian sebagai e:
    cetak (e)

Kod di atas mentakrifkan model pengguna menggunakan basemodel Pydantic, menguatkuasakan nama sebagai rentetan dan umur sebagai integer. Ia mengesahkan data yang betul tetapi menimbulkan ralat pengesahan apabila data tidak sah (rentetan untuk umur) disediakan.

Output:

Paksaan jenis auto

 dari basemodel import pydantic
Produk Kelas (BaseModel):
    Harga: Terapung
    Kuantiti: Int

# Data dengan jenis yang tidak sesuai
produk = produk (harga = "19.99", kuantiti = "5")
Cetak (produk)

cetak (jenis (produk.price))
cetak (jenis (produk.quantity))

Di sini, model produk dengan harga sebagai terapung dan kuantiti sebagai integer. Pydantic secara automatik memaksa input rentetan ("19.99" dan "5") ke dalam jenis yang betul (Float dan Int), menunjukkan ciri penukaran jenisnya.

Output:

Model bersarang

 dari basemodel import pydantic
Alamat Kelas (BaseModel):
    Jalan: Str
    Bandar: Str
Pengguna Kelas (BaseModel):
    Nama: Str
    Alamat: Alamat

# Data yang sah
pengguna = pengguna (name = "bob", alamat = {"street": "123 main st", "city": "wonderland"})
Cetak (pengguna)

# Akses atribut bersarang
cetak (user.address.city)

Di sini, kami menentukan model pengguna bersarang yang mengandungi model alamat . Pydantic membolehkan kamus pengesahan bersarang dan penukaran automatik ke dalam model. Data yang sah memulakan objek pengguna , dan anda boleh mengakses atribut bersarang seperti ' user.address.city' secara langsung.

Output:

Pengesahan dengan peraturan tersuai

 Dari Pydantic Import Basemodel, Field, Field_Validator

Pengguna Kelas (BaseModel):
    Nama: Str
    Umur: int = medan (..., gt = 0, description = "umur mesti lebih besar daripada sifar")

    @field_validator ("Nama")
    def name_must_be_non_empty (cls, nilai):
        jika tidak nilai.strip ():
            Naikkan ValueError ("Nama tidak boleh kosong")
        nilai pulangan

# Data yang sah
pengguna = pengguna (name = "Charlie", umur = 25)
Cetak (pengguna)

# data tidak sah
Cuba:
    pengguna = pengguna (name = "", umur = -5)
Kecuali pengecualian sebagai e:
    cetak (e)

Di sini, kami menentukan model pengguna dengan peraturan pengesahan, umur mestilah lebih besar daripada 0, dan nama tidak boleh kosong (disahkan melalui kaedah name_must_be_non_empty ). Data yang sah mencipta contoh pengguna , sementara data tidak sah (nama kosong atau umur negatif) menimbulkan kesilapan pengesahan terperinci, menunjukkan keupayaan pengesahan Pydantic.

Output:

Ini adalah beberapa contoh utama Pydantic Saya harap mereka membantu anda memahami prinsip asas pengesahan data.

Apakah ejen AI?

Ejen AI adalah sistem pintar yang direka untuk melaksanakan tugas secara autonomi, membuat keputusan, dan berinteraksi dengan persekitaran mereka untuk mencapai objektif tertentu. Ejen -ejen ini bukan perkembangan pesat baru tetapi baru -baru ini dalam AI generatif dan menggabungkannya dengan ejen membuat pembangunan perisian agensi pada era baru. Sekarang, ejen boleh memproses input, melaksanakan tindakan, dan menyesuaikan diri secara dinamik. Tingkah laku mereka meniru penyelesaian masalah seperti manusia, membolehkan mereka berfungsi dalam pelbagai domain dengan campur tangan manusia yang minimum.

Apakah aliran kerja agentik?

Aliran kerja yang agentik merujuk kepada struktur, urutan tugas yang didorong oleh matlamat yang diuruskan dan dilaksanakan oleh satu atau beberapa agen AI. Aliran kerja tradisional yang tegar, aliran kerja agentik mempamerkan kebolehsuaian, autonomi, dan kesedaran konteks. Ejen AI dalam aliran kerja ini secara bebas boleh membuat keputusan, mewakilkan subtask, dan belajar dari maklum balas, yang membawa kepada hasil yang cekap dan dioptimumkan.

Penggunaan moden agen AI dan aliran kerja agentik

Penyepaduan ejen AI dan aliran kerja agentik telah merevolusikan industri dengan mengautomasikan tugas-tugas yang kompleks, meningkatkan pengambilan keputusan, dan kecekapan memandu. Sistem pintar ini menyesuaikan diri secara dinamik, membolehkan penyelesaian yang lebih bijak merentasi pelbagai domain.

Automasi Perniagaan

Ejen AI mengautomasikan tugas berulang seperti sokongan pelanggan melalui chatbots, pengurusan e -mel, dan pengoptimuman saluran paip jualan. Mereka meningkatkan produktiviti dengan membebaskan sumber manusia dari tugas bernilai tinggi.

Pembangunan perisian

Ejen berkuasa AI mempercepatkan hayat perisian dengan menghasilkan, menguji, dan menyahpepijat kod, dengan itu mengurangkan masa pembangunan dan kesilapan manusia.

Penjagaan kesihatan

Ejen AI membantu dalam diagnosis perubatan, pemantauan pesakit, dan pemperibadian rawatan, meningkatkan penyampaian penjagaan kesihatan dan kecekapan operasi.

Kewangan

Aliran kerja Agentik dalam sistem kewangan mengotomatisasi pengesanan penipuan, penilaian risiko, dan analisis pelaburan, yang membolehkan pengambilan keputusan yang lebih cepat dan lebih dipercayai.

E-dagang

Agensi perisikan meningkatkan keperibadian dalam pengalaman membeli -belah, mengoptimumkan cadangan produk dan perkhidmatan pelanggan.

Kebangkitan ejen AI dan aliran kerja agentik menandakan peralihan ke arah sistem yang sangat autonomi yang mampu menguruskan proses yang kompleks. Keupayaan penyesuaian dan pembelajaran mereka menjadikan mereka sangat diperlukan untuk industri moden, memacu inovasi, skalabilitas, dan kecekapan di seluruh domain. Apabila AI terus berkembang, ejen AI akan terus mengintegrasikan ke dalam aliran kerja harian kami, mengubah cara tugas diuruskan dan dilaksanakan.

Apakah kerangka Pydanticai?

Pydanticai adalah kerangka agen Python yang dibangunkan oleh pencipta Pydantic, FastAPI untuk menyelaraskan pembinaan aplikasi gred pengeluaran menggunakan AI generatif, ia menekankan jenis keselamatan, reka bentuk model-agnostik, dan integrasi lancar dengan model bahasa besar (LLMS).

Ciri -ciri utama Pydanticai termasuk:

• Sokongan Model-Agnostik: Pydanticai serasi dengan pelbagai model, termasuk OpenAI, Antropic, Gemini, Groq, Mistral, dan Ollama, dengan antara muka yang mudah untuk menggabungkan model tambahan.
• Jenis-keselamatan: Memanfaatkan sistem jenis Python dan pengesahan Pydantic, Pydanticai memastikan pembangunan ejen yang mantap dan berskala.
• Sistem Suntikan Ketergantungan: Ia memperkenalkan mekanisme suntikan ketergantungan novel, ty-safe, meningkatkan ujian dan pembangunan yang didorong oleh penilaian.
• Pengesahan tindak balas berstruktur: Menggunakan keupayaan pengesahan Pydantic, memastikan tindak balas struktur yang tepat dan boleh dipercayai.
• Integrasi Logfire: Menawarkan integrasi dengan Pydantic Logfire untuk debugging dan pemantauan aplikasi yang dipertingkatkan.

Berikut adalah contoh minimum Pydanticai:

 Import OS
dari ejen import pydantic_ai
dari pydantic_ai.models.gemini import geminimodel
dari dotenv import load_dotenv

LOAD_DOTENV ()

Gemini_api_key = os.getenv ("<google_api_key>")

Model = GeminiModel (
    "Gemini-1.5-Flash",
    api_key = Gemini_api_key,
)

ejen = ejen (
    model = model,
    System_prompt = "Jadilah ringkas, balas dengan satu ayat.",
)

hasil = agen.run_sync ('Di manakah "Hello World" berasal?')
cetak (result.data)</google_api_key>

Output:

Kini sudah tiba masanya untuk melakukan beberapa perkara sebenar. Kami akan membina penjanaan pertanyaan SQL Postgres menggunakan rangka kerja agen Pydanticai.

Bermula dengan projek anda

Letakkan asas untuk projek anda dengan panduan langkah demi langkah untuk menubuhkan alat dan persekitaran penting.

Menetapkan persekitaran

Kami akan mewujudkan persekitaran conda untuk projek ini.

 #Buat env
$ conda create -nama sql_gen python = 3.12

# Aktifkan env
$ conda mengaktifkan sql_gen

Sekarang, buat folder projek

 # Buat folder
$ mkdir sql_code_gen
# Tukar ke folder
$ cd sql_code_gen

Pasang Postgres dan Load Database

Untuk memasang pasang Postgres, psql-command, dan pgadmin-4, hanya pergi ke edbdownload pemasang anda untuk sistem anda, dan pasang semua alat dalam satu perjalanan.

Sekarang muat turun pangkalan data dvdrental dari hereand untuk memuatkannya ke postgres ikuti langkah -langkah ini

Langkah1: Buka terminal anda

 PSQL -U Postgres

# Ia akan meminta kata laluan meletakkannya

Langkah2: Buat pangkalan data

 # Di postgres =#

Buat pangkalan data dvdrental;

Langkah3: Perintah untuk Terminal

Sekarang, keluar dari arahan PSQL dan kemudian taipkan terminal

 pg_restore -u postgres -d dvdrental d: /sampledb/postgres/dvdrental.tar

Langkah4: Berhubung dengan PSQL

Sekarang, sambungkan ke PSQL dan periksa sama ada pangkalan data anda dimuatkan atau tidak.

 PSQL -U Postgres

# Berhubung dengan dvdrental
\ c dvdrental

# mari kita lihat jadual

\ dt

Output:

Sekiranya anda melihat jadual di atas maka anda baik -baik saja. Kami bersedia untuk memulakan projek utama kami.

Sekarang pasang perpustakaan Python yang diperlukan ke dalam SQL_Gen Conda Env.

 Conda Aktifkan SQL_GEN

# Pasang perpustakaan
PIP Pasang Pydantic Asyncpg Asyncio Pydantic-ai 

PIP Pasang Python-Dotenv Fastapi Google-Generativeai

PIP Pasang DevTools jenis-jenis-jenis-jenis

Struktur projek

Projek kami mempunyai 4 fail iaitu Main, Model, Perkhidmatan, dan Skema.

 sql_query_gen/
|
| ---main.py
|--Models.py
|-schema.py
|-service.py
|-. Env
| --__ init__.py
|-. Gitignore

Panduan Langkah demi Langkah untuk Melaksanakan Projek Anda

Menyelam langkah -langkah terperinci dan teknik praktikal untuk membawa projek anda dari konsep kepada realiti dengan panduan pelaksanaan komprehensif ini.

Model Pydantic

Kami akan mulakan dengan membuat model data dalam fail model.py

 Dari DataClass Import DataClass
dari menaip import anotasi
Import asyncpg
dari annotated_types import minlen
dari Pydantic Import Basemodel, Field

@DataClass
Deps Kelas:
    Conn: asyncpg.connection

Kejayaan Kelas (Basemodel):
    SQL_Query: Annotated [str, minlen (1)]
    Penjelasan: str = medan ("", keterangan = "Penjelasan pertanyaan SQL, sebagai Markdown")

Kelas InvalidRequest (BaseModel):
    error_message: str

Dalam kod di atas,

• Kelas DEPS menguruskan dependensi sambungan pangkalan data. @DataClass secara automatik menjana kaedah khas seperti __init__ dan __repr__. Conn ditaip sebagai `asyncpg.connection` dan mewakili sambungan PostgreSQL aktif. Reka bentuk ini mengikuti corak suntikan ketergantungan, menjadikan kod lebih dapat diuji dan dikekalkan.
• Kelas Kejayaan mewakili penjanaan SQL-Query yang berjaya, SQL_Query mestilah rentetan yang tidak kosong ( Minlen (1)) dan menggunakan anotasi untuk menambah kekangan pengesahan. Penjelasan adalah medan pilihan dengan rentetan kosong lalai.
• Kelas InvalidRequest adalah model tindak balas ralat, yang mewakili percubaan penjanaan SQL yang gagal.

Kod ini menubuhkan asas bagi pengurusan sambungan pangkalan data, pengesahan input, pengendalian tindak balas berstruktur, dan pengendalian ralat.

Modul perkhidmatan

Sekarang, kami akan melaksanakan perkhidmatan Pydanticai untuk penjanaan SQL dalam modul perkhidmatan.

Import Perpustakaan dan Konfigurasi

 Import OS
dari menaip kesatuan import
dari dotenv import load_dotenv
Import asyncpg
dari typing_extensions import sypealias
dari ejen import pydantic_ai, modelretry, runcontext
dari pydantic_ai.models.gemini import geminimodel
dari skema import db_schema
Dari model import Deps, kejayaan, Invalidrequest

Untuk mengkonfigurasi, buat fail .env di akar projek dan letakkan kunci API Gemini anda di sana

 # .env

Gemini_api_key = "asgfhkdhjy457gthjhajbsd"

Kemudian dalam fail service.py:

 LOAD_DOTENV ()

Gemini_api_key = os.getenv ("Google_API_KEY")

Ia akan memuatkan kunci API Google dari `. env `fail.

Membuat Model dan Ejen

 Respons: Typealias = Union [Kejayaan, InvalidRequest]

Model = GeminiModel (
    "Gemini-1.5-Flash",
    api_key = Gemini_api_key,
)

ejen = ejen (
    model,
    result_type = respons, # jenis: abaikan
    deps_type = deps,
)

• Mula -mula menentukan jenis respons yang boleh berjaya atau Invalidrequest
• Memulakan model Flash Gemini 1.5 dengan kekunci API
• Buat ejen pydanticai dengan jenis tindak balas dan ketergantungan yang ditentukan

Definisi segera sistem

Sekarang kita akan menentukan sistem prompt untuk penjanaan pertanyaan SQL kami.

 @agen.system_prompt
async def system_prompt () -> str:
    kembali f "" "\

Memandangkan jadual rekod postgresQL berikut, tugas anda adalah
Tulis pertanyaan SQL yang sesuai dengan permintaan pengguna.

Skema pangkalan data:
{Db_schema}

Contoh
    Permintaan: Cari semua filem dengan kadar sewa lebih daripada $ 4.00 dan penarafan 'PG'
    Respons: Pilih Tajuk, Rental_Rate
    Dari filem
    Di mana sewa_rate> 4.00 dan rating = 'pg';
Contoh
    Permintaan: Cari filem dengan panjang terpanjang
    Respons: Pilih Tajuk, Panjang
    Dari filem
    Di mana panjang = (pilih max (panjang) dari filem);
Contoh
    Permintaan: Cari tempoh sewa purata untuk filem dalam setiap kategori
    Respons: Pilih C.Name, AVG (f.rental_duration) sebagai purata_rental_duration
    Dari kategori c
    Sertai Film_Category FC pada c.category_id = fc.category_id
    Sertai Filem F di fc.film_id = f.film_id
    Kumpulan oleh C.Name
    Perintah oleh purata_rental_duration desc;
"" "

Di sini, kami menentukan konteks asas untuk model AI dan memberikan pertanyaan contoh untuk membimbing tindak balas model. Kami juga memasukkan maklumat skema pangkalan data dalam model supaya model dapat menganalisis skema dan menghasilkan respons yang lebih baik.

Pengesahan tindak balas

Untuk membuat respons dari model AI tanpa ralat dan sehingga keperluan projek, kami hanya mengesahkan respons.

 @agen.result_validator
async def validate_result (ctx: runContext [deps], hasil: respons) -> respons:
    jika isInstance (hasil, InvalidRequest):
        Keputusan pulangan

    # Gemini sering menambah tindak balas extraneos ke SQL
    result.sql_query = result.sql_query.replace ("\\", "")
    jika tidak result.sql_query.upper (). startswith ("pilih"):
        Naikkan ModelRetry ("Sila buat pertanyaan pilih")

    Cuba:
        menunggu ctx.deps.conn.execute (f "jelaskan {result.sql_query}")
    kecuali asyncpg.exceptions.postgreSerror sebagai e:
        meningkatkan modelRetry (f "tidak sah sql: {e}") dari e
    lain:
        Keputusan pulangan

Di sini, kami akan mengesahkan dan memproses pertanyaan SQL yang dihasilkan

Langkah Pengesahan Utama:

• Pulangan segera jika hasilnya adalah Invalidrequeste, bersihkan backslashes tambahan
• Pastikan pertanyaan adalah pernyataan pilih
• Mengesahkan sintaks SQL menggunakan PostgreSQL Jelaskan
• Meningkatkan Model Retry untuk Pertanyaan Tidak Sah

Skema pangkalan data

Untuk mendapatkan skema pangkalan data anda, buka PGAdmin4 yang telah anda pasang semasa persediaan Postgres, pergi ke pangkalan data ` dvDrental` , klik kanan di atasnya, dan klik` erd untuk pangkalan data `.
Anda akan mendapat gambarajah ERD di bawah, kini menjana SQL dari ERD (lihat tanda hitam bulat pada imej).

Salin skema ke modul skema.py:

 # skema.py
Db_schema = "" "
Bermula;


Buat jadual jika tidak ada awam.Actor
(
    pelakon_id siri tidak batal,
    watak pertama_name berbeza -beza (45) menyusun pg_catalog. "lalai" tidak null,
    watak last_name berbeza -beza (45) menyusun pg_catalog. "lalai" tidak null,
    last_update Timestamp tanpa zon waktu tidak null lalai sekarang (),
    Kekunci utama pelakon_pkey (actor_id)
);
.
.
.
  
.
.
.
"" "

Blok kod di atas sangat dipotong , untuk mendapatkan kod penuh sila lawati repo projek.

Sekarang, bahawa semua modul yang diperlukan telah selesai, masa untuk melaksanakan kaedah dan ujian utama.

Melaksanakan utama

Kami akan melakukan definisi fungsi utama dan pengendalian segera.

 Import Asyncio
Import OS
Import sys
dari menaip kesatuan import
dari dotenv import load_dotenv
Import asyncpg
dari debug import devtools
dari typing_extensions import sypealias
dari ejen import pydantic_ai
dari pydantic_ai.models.gemini import geminimodel
Dari model import Deps, kejayaan, Invalidrequest

LOAD_DOTENV ()

Gemini_api_key = os.getenv ("Google_API_KEY")


Respons: Typealias = Union [Kejayaan, InvalidRequest]

Model = GeminiModel (
    "Gemini-1.5-Flash",
    api_key = Gemini_api_key,
)

ejen = ejen (
    model,
    result_type = respons, # jenis: abaikan
    deps_type = deps,
)


async def main ():
    jika len (sys.argv) == 1:
        prompt = "Sila buat pertanyaan pilih"
    lain:
        prompt = sys.argv [1]

    # Sambungan ke pangkalan data
    Conn = menanti asyncpg.connect (
        pengguna = "Postgres",
        kata laluan = "avizyt",
        tuan rumah = "localhost",
        port = 5432,
        pangkalan data = "dvdrental",
    )
    Cuba:
        Deps = Deps (Conn)
        hasil = menunggu ejen.run (prompt, deps = deps)
        hasil = debug (result.data)
        Cetak ("======== Pertanyaan anda =========")
        cetak (debug (result.sql_query))
        Cetak ("======== Penjelasan =========")
        cetak (debug (result.explanation))

    Akhirnya:
        menanti conn.close ()


jika __name__ == "__main__":
    asyncio.run (utama ())

Di sini, pertama, tentukan fungsi utama yang tidak segerak, dan periksa hujah baris arahan untuk pertanyaan klien. Jika tiada args disediakan, gunakan prompt lalai.

Kemudian kami menetapkan parameter sambungan Postgres untuk berhubung dengan perkhidmatan pangkalan data DVDrental.

Dalam blok cuba, buat contoh DEPS dengan sambungan pangkalan data, jalankan ejen AI dengan prompt, memproses hasil menggunakan fungsi debug ( PIP Install DevTools ). Kemudian mencetak output diformat termasuk pertanyaan SQL yang dihasilkan dan penjelasan pertanyaan. Selepas itu, kami akhirnya menutup sambungan pangkalan data.

Sekarang jalankan modul utama seperti di bawah:

 # di terminal
python main.py "Dapatkan jumlah sewa untuk setiap pelanggan"

Output:

Selepas menguji pertanyaan SQL di pgadmin4:

Wow! Ia berfungsi seperti yang kita mahukan. Uji lebih banyak pertanyaan seperti ini dan nikmati pembelajaran.

Kesimpulan

Projek ini merupakan langkah penting dalam membuat interaksi pangkalan data lebih intuitif dan boleh diakses. Dengan menggabungkan kuasa AI dengan prinsip kejuruteraan perisian yang mantap, kami telah mencipta alat yang bukan sahaja menjana pertanyaan SQL tetapi melakukannya dengan cara yang selamat, pendidikan, dan praktikal untuk kegunaan dunia nyata.

Kejayaan pelaksanaan ini menunjukkan potensi AI untuk meningkatkan daripada menggantikan operasi pangkalan data tradisional, menyediakan alat yang berharga untuk pembelajaran dan produktiviti.

Repo Projek - Semua kod yang digunakan dalam projek ini boleh didapati di sini.

Takeaways utama

• Pydanticai membolehkan penjanaan kod yang cerdas dan konteks.
• Gemini-1.5-Flash menyediakan pemahaman bahasa semulajadi yang maju untuk tugas-tugas teknikal.
• Ejen AI boleh mengubah cara kita berinteraksi dengan pangkalan data dan menjana kod.
• Pengesahan yang teguh adalah penting dalam sistem kod AI yang dihasilkan.

Soalan yang sering ditanya

Q 1. Apakah kelebihan pydanticai untuk generasi SQL?

A. Pydanticai menawarkan penjanaan kod yang selamat, disahkan dengan pemeriksaan ralat terbina dalam dan pemahaman kontekstual.

Q 2. Bagaimana Gemini-1.5-Flash menyumbang kepada projek itu?

A. Model Gemini menyediakan pemprosesan bahasa semulajadi yang maju, menterjemahkan pertanyaan manusia yang kompleks ke dalam pernyataan SQL yang tepat.

Q 3. Bolehkah projek ini diperluaskan ke aplikasi AI yang lain?

A. Sudah tentu! Senibina boleh disesuaikan untuk penjanaan kod, transformasi data, dan automasi pintar merentasi pelbagai domain.

Media yang ditunjukkan dalam artikel ini tidak dimiliki oleh Analytics Vidhya dan digunakan atas budi bicara penulis.

Atas ialah kandungan terperinci Membina aplikasi bertenaga LLM-gred pengeluaran dengan Pydanticai. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!