---
title: "Künstliche Intelligenz bedient Datenbank und API"
description: "Erfahre, wie KI mit Python SQLModel und Google Vertex AI Datenbanken und APIs verknüpft. KI-gestützte Anfragen in natürlicher Sprache leicht gemacht."
canonical_url: "https://www.blueshoe.de/blog/kuenstliche-intelligenz-datenbank-api/"
---
Überall wird über Künstliche Intelligenz gesprochen - auch wir bei Blueshoe kommen nicht an dem Thema vorbei. In diesem Blogpost bauen wir einen simpleren und doch beeindruckenden Case mit Google’s Vertex AI und dem Python Paket SQLModel. Wir demonstrieren, wie Datenbanken und APIs in die KI-Modelle eingewoben werden können. Das Szenario soll es ermöglichen, einfach Anfragen in natürlicher Sprache an unsere Datenbank zu stellen und hier Antworten zu erhalten.
Vertex AI und SQLModel
Die Plattform Vertex AI ist ein Produkt der Google Cloud und bietet Entwicklern die Möglichkeit, generative AI in ihre Applikationen einzubinden. Die Möglichkeiten sind zahlreich: Input und Output können via Text, Audio und Video erfolgen und es stehen verschiedene AI Modelle zur Auswahl. Für diesen Blogpost beschränken wir uns auf Text als Eingabe- und Ausgabemedium. Vertex AI Tutorials wie dieses zeigen, wie einfach die Integration in Projekte gelingt.
SQLModel ist ein Python Paket, welches auf Pydantic (einer Validierungsbiibliothek) aufsetzt und es ermöglicht, die Python-Datenmodelle in Datenbanken zu speichern oder aus diesen zu lesen. Praktisch ein ORM (=Object–relational mapping) auf Pydantic Basis, das sich hervorragend für eine KI Datenbank eignet. Künstliche Intelligenz mit Python zu kombinieren, wird damit besonders einfach.
Datenmodell und Generierung von Daten
Folgendes Szenario nehmen wir an:
Wir sind ein Buchladen und führen eine Datenbank mit Büchern. Es ist bekannt, wie viele Exemplare pro Buch im Lager vorhanden sind. Zu jedem Buch ist der Autor bekannt.
Das Datenmodell sieht folgendermaßen aus:
```python
class Author(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
first_name: str
last_name: str
birthday: date
class Book(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
author_id: int = Field(default=None, foreign_key="author.id")
num_in_stock: int = 0
```
Bücher und Autoren sind über eine klassische Foreign-Key-Beziehung miteinander verbunden. Es lassen sich mit SQLModel nun ganz einfach Queries an die Datenbank formulieren, um eine KI API aufzubauen - z.B. die Selektion aller Autoren mit einem bestimmten Vor- und Nachnamen:
```python
# select Author with matching first_name and last_name
statement = select(Author).where(Author.first_name == first_name, Author.last_name == last_name)
```
Soweit so gut. Via Polyfactory generieren wir uns noch ein paar Testdaten:
```python
class AuthorFactory(ModelFactory[Author]):
__model__ = Author
__faker__ = Faker(locale="de_DE")
id = Use(lambda: None)
@classmethod
def first_name(cls) -> str:
return cls.__faker__.first_name()
@classmethod
def last_name(cls) -> str:
return cls.__faker__.last_name()
class BookFactory(ModelFactory[Book]):
__model__ = Book
__faker__ = Faker(locale="de_DE")
id = Use(lambda: None)
@classmethod
def name(cls) -> str:
return cls.__faker__.catch_phrase()
def create_authors():
for i in range(0, 1000):
author = AuthorFactory.build()
with Session(engine) as session:
session.add(author)
session.commit()
for i in range(1, randrange(1, 10)):
create_book(author_id=author.id)
def create_book(author_id):
book = BookFactory.build(author_id=author_id)
with Session(engine) as session:
session.add(book)
session.commit()
# init sqlite
engine = create_engine("sqlite:///database.db")
SQLModel.metadata.create_all(engine)
# call create fcnt
create_authors()
```
Und schon haben wir 1000 verschiedene Autoren mit zwischen 1 und 10 Büchern. Die Bücher bekommen zufällige Verfügbarkeiten (Anzahl im Lager) zugeordnet.
Wir können auch für Dich KI-Lösungen bauen.
Verbindung mit Vertex AI
Zuallererst wäre zu definieren, auf welche Funktionalität unser Agent Zugriff haben soll. Wir nehmen an, dass der Agent Bücher für einen bestimmten Autor ermitteln können soll und auch die Anzahl von Exemplaren auf dem Lager für ein bestimmtes Buch kennen muss.
Dafür werden folgende Hilfsfunktionen angelegt:
```python
from utils import (
get_book_id_by_title,
get_books_for_author,
get_num_in_stock_for_book,
)
```
Vertex AI braucht nun Informationen über die Funktionen, was diese tun und welche Eingabeparameter zu erwarten sind. Dies wird mithilfe von FunctionDeclarations gemacht:
```python
get_authors_for_book_func = FunctionDeclaration(
name=GET_BOOK_BY_AUTHOR,
description="Get a list of book names for an author.",
parameters={
"type": "object",
"properties": {
"first_name": {
"type": "string",
"description": "The first name of the author",
},
"last_name": {
"type": "string",
"description": "The last name of the author",
},
},
},
)
```
Die Funktion selbst sieht folgendermaßen aus:
```python
def get_books_for_author(first_name: str, last_name: str):
with Session(engine) as session:
statement = select(Author).where(Author.first_name == first_name, Author.last_name == last_name)
author = session.exec(statement).first()
statement = select(Book).where(Book.author_id == author.id)
books = session.exec(statement=statement).all()
return [book.name for book in books]
```
Die Funktionen werden in ein "Tool" zusammengefasst und dem Modell zur Verfügung gestellt:
```python
tools = Tool(
function_declarations=[
get_authors_for_book_func,
get_book_id_by_title_func,
get_num_in_stock_for_book_func,
],
)
model = GenerativeModel(
model_name="gemini-1.5-pro-002",
generation_config=GenerationConfig(temperature=0),
tools=[tools],
)
```
Das Modell kann den Input eines Nutzers nun klassifizieren und eine Einschätzung geben, welche der Funktionen verwendet werden soll. Diese kann dann aufgegriffen werden:
```python
if function_calls:
api_responses = []
for func in function_calls:
if func.name == GET_BOOK_BY_AUTHOR:
api_responses.append(
{
"name": func.name,
"content": get_books_for_author(
first_name=func.args["first_name"],
last_name=func.args["last_name"],
),
}
)
elif func.name == GET_BOOK_ID_BY_TITLE:
api_responses.append(
{
"name": func.name,
"content": get_book_id_by_title(
title=func.args["title"],
),
}
)
elif func.name == GET_NUM_IN_STOCK_FOR_BOOK:
api_responses.append(
{
"name": func.name,
"content": get_num_in_stock_for_book(
title=func.args["title"],
),
}
)
# Return the API response to Gemini
for api_response in api_responses:
name = api_response.pop("name")
response = chat_session.send_message(
[
Part.from_function_response(
name=name,
response=api_response,
)
]
)
print(response.text)
```
Das Modell extrahiert also die Parameter aus der Eingabe des Nutzers. Diese kann dann im Funktionsaufruf verwendet werden.
Nun kann der Chat starten!
**Which books are written by Guenther Hendriks?**
Guenther Hendriks has written the following books: Digitized optimal circuit, Future-proofed content-based groupware, Universal clear-thinking Local Area Network, Digitized scalable service-desk, and Innovative full-range protocol.
**How many copies of the first of those books are available?**
There are 2089 copies of "Digitized optimal circuit" in stock.
Fazit
Die API von Vertex AI funktioniert generell gut. Aktuell dauert die Rückmeldung immer ein paar Sekunden, was je nach Use-Case eventuell zu viel sein könnte. Das Interface ist intuitiv und einfach zu bedienen. Für manche Anfragen kommt gar keine Rückmeldung von Vertex AI, was dann abgefangen werden muss.
Vertex AI macht es möglich, bestehende APIs und Datenbanken über natürliche Sprache zugänglich zu machen, was cool und schnell funktioniert, allerdings noch etwas ausreifen muss. Es erlaubt eine effiziente Nutzung der KI Datenbank und der Einbindung in verschiedene Systeme. Besonders für Entwickler, die KI programmieren mit Python wollen, ist dies eine spannende Lösung.
## Sitemap
See the full [sitemap](/sitemap.md) for all pages.