declarai

---

Dokumentation : https://declarai.com

Quellcode : https://github.com/vendi-ai/declarai

---

Was ist Declarai?

Declarai verwandelt Ihren Python -Code in LLM -Aufgaben, sodass Sie LLM problemlos in Ihre vorhandene Codebasis integrieren können. Es arbeitet nach einem einfachen Prinzip: Definieren Sie einfach eine Python -Funktion/-klasse. Durch Annotieren dieser Funktion mit Docstrings und Typ -Tipps geben Sie einen klaren Anweisungssatz für das KI -Modell ohne zusätzliche Anstrengungen an.

Sobald Sie Ihre Funktion deklariert haben, erfasst Declarai die DOCStrings der Funktion intelligent und tippen Tipps in eine Aufforderung für das KI -Modell ein, um sicherzustellen, dass das Modell genau versteht, was erforderlich ist.

Nach der Ausführung der Aufgabe ruft Declarai die Antwort der KI ab und analysiert sie, um sie wieder in den deklarierten Rückgabetyp Ihrer Python -Funktion zu übersetzen. Dadurch werden die manuellen Parsen oder Nachbearbeitung von Ihrer Seite beseitigt.

Declarai hält es einheimisch: Im Kern geht es bei Declarai darum, einheimische Python -Praktiken zu nutzen. Sie müssen keine neue Syntax lernen oder sich an ein anderes Codierungsparadigma anpassen. Schreiben Sie einfach Python -Funktionen wie Sie immer und lassen Sie Declarai die KI -Integration nahtlos umgehen.

---

Hauptkomponenten?

Aufgaben

KI -Aufgaben werden für jede Geschäftslogik oder Transformation verwendet.

 import declarai

gpt_35 = declarai . openai ( model = "gpt-3.5-turbo" )

@ gpt_35 . task 
def rank_by_severity ( message : str ) -> int :
    """
    Rank the severity of the provided message by it's urgency.
    Urgency is ranked on a scale of 1-5, with 5 being the most urgent.
    :param message: The message to rank
    :return: The urgency of the message
    """


rank_by_severity ( message = "The server is down!" )

>> > 5

rank_by_severity ( message = "How was your weekend?" ))

>> > 1

Chat?

KI -Chats werden für eine iterative Konversation mit dem KI -Modell verwendet, bei dem sich das KI -Modell an frühere Nachrichten und Kontext erinnern kann.

 import declarai

gpt_35 = declarai . openai ( model = "gpt-3.5-turbo" )

@ gpt_35 . experimental . chat
class SQLBot :
    """
    You are a sql assistant. You help with SQL related questions 
    """


sql_bot = SQLBot ()
sql_bot . send ( "When should I use a LEFT JOIN?" )

> " You should use a LEFT JOIN when you want to return all rows from ....

Merkmale:

• ? Intelligente Eingabeaufforderungen : Generieren Sie automatisch Eingabeaufforderungen mit Typ -Tipps und Docstrings.
• ? Konversations -KI : Chat -Schnittstelle mit Speicher- und Kontextverwaltung.
• ⚡ Echtzeit-Streaming : Stream-LLM-Antworten, deren Fertigstellung länger dauert.
• Pydantic Model Parsing : Nahe LLM -Antworten in pydantische Modelle analysieren.
• ? Pythonisch : Einheimisches Verständnis und Parsen von LLM -Reaktionen in Python -Primitiven.
• ? Mehrere KI -Backends : Integriert in OpenAI & Azure AI LLM -Anbieter.
• ? Middleware : Anpassen und erweitern Sie das Verhalten von Aufgaben mit einem modularen Middleware -System.
• ? Bald kommen : Integration mit Huggingface Hub

QuickStart

Installation

pip install declarai

Aufstellen

 export OPENAI_API_KEY= < your openai token >

oder übergeben Sie das Token bei der Initialisierung des Deklarai -Objekts

 import declarai

gpt_35 = declarai . openai ( model = "gpt-3.5-turbo" , openai_token = "<your-openai-key>" )

Grundnutzung

Basteln Sie mit dem @task Dekorator mit AI-betriebenen Funktionen. Fügen Sie einfach einige Typ -Hinweise und ein bisschen Dokumentation hinzu und schauen Sie sich Declarai an, seine Magie zu machen!

 import declarai

gpt_35 = declarai . openai ( model = "gpt-3.5-turbo" )

@ gpt_35 . task
def generate_poem ( title : str ) -> str :
    """
    Write a 4 line poem on the provided title
    """


res = generate_poem (
    title = "Declarai, the declarative AI framework for LLMs"
)
print ( res )
# Declarai, the AI framework,
# Empowers LLMs with declarative power,
# Efficiently transforming data and knowledge,
# Unlocking insights in every hour.

Nicht das beste Gedicht da draußen, aber hey! Sie haben Ihren ersten deklarativen KI -Code geschrieben!

Declarai zielt darauf ab, sauberen und lesbaren Code zu fördern, indem die Verwendung von DOC-Stringen und Schreiben durchgesetzt wird. Der resultierende Code ist lesbar und leicht zu warten.

Aufgaben mit Python Native Output Parsing

Python -Primitive

 import declarai

gpt_35 = declarai . openai ( model = "gpt-3.5-turbo" )

@ gpt_35 . task
def rank_by_severity ( message : str ) -> int :
    """
    Rank the severity of the provided message by it's urgency.
    Urgency is ranked on a scale of 1-5, with 5 being the most urgent.
    :param message: The message to rank
    :return: The urgency of the message
    """


rank_by_severity ( message = "The server is down!" )

>> > 5
rank_by_severity ( message = "How was your weekend?" ))

>> > 1

Python -Listen/Diktate usw.

 from typing import List
import declarai

gpt_35 = declarai . openai ( model = "gpt-3.5-turbo" )

@ gpt_35 . task
def multi_value_extraction ( text : str ) -> List [ str ]:
    """
    Extract the phone numbers from the provided text
    :param text: content to extract phone number from
    :return: The phone numbers that where identified in the input text
    """


multi_value_extraction (
    text = "Hey jenny, n you can call me at 124-3435-132. n "
         "you can also reach me at [phone]"
)
>> > [ '124-3435-132' , '[phone]' ]

Python -komplexe Objekte

 from datetime import datetime
import declarai

gpt_35 = declarai . openai ( model = "gpt-3.5-turbo" )

@ gpt_35 . task
def datetime_parser ( raw_date : str ) -> datetime :
    """
    Parse the input into a valid datetime string of the format YYYY-mm-ddThh:mm:ss
    :param raw_date: The provided raw date
    :return: The parsed datetime output
    """


datetime_parser ( raw_date = "Janury 1st 2020" ))

>> > 2020 - 01 - 01 00 : 00 : 00

Pydantische Modelle

 from pydantic import BaseModel
from typing import List , Dict
import declarai


class Animal ( BaseModel ):
    name : str
    family : str
    leg_count : int

gpt_35 = declarai . openai ( model = "gpt-3.5-turbo" )

@ gpt_35 . task
def suggest_animals ( location : str ) -> Dict [ int , List [ Animal ]]:
    """
    Create a list of numbers from 0 to 5
    for each number, suggest a list of animals with that number of legs
    :param location: The location where the animals can be found
    :return: A list of animal leg count and for each count, the corresponding animals
    """


suggest_animals ( location = "jungle" )

>> > {
       0 : [
           Animal ( name = 'snake' , family = 'reptile' , leg_count = 0 )
       ], 
       2 : [
           Animal ( name = 'monkey' , family = 'mammal' , leg_count = 2 ), 
           Animal ( name = 'parrot' , family = 'bird' , leg_count = 2 )
       ], 
       4 : [
          Animal ( name = 'tiger' , family = 'mammal' , leg_count = 4 ), 
          Animal ( name = 'elephant' , family = 'mammal' , leg_count = 4 )
       ]
 }

Jinja -Vorlagen?

 import declarai

gpt_35 = declarai . openai ( model = "gpt-3.5-turbo" )

@ gpt_35 . task
def sentiment_classification ( string : str , examples : List [ str , int ]) -> int :
    """
    Classify the sentiment of the provided string, based on the provided examples.
    The sentiment is ranked on a scale of 1-5, with 5 being the most positive.
    {% for example in examples %}
    {{ example[0] }} // {{ example[1] }}
    {% endfor %}
    {{ string }} //
    """
    
sentiment_classification ( string = "I love this product but there are some annoying bugs" ,
                         examples = [[ "I love this product" , 5 ], [ "I hate this product" , 1 ]])

>> > 4

Einfache Chat -Oberfläche

 import declarai

gpt_35 = declarai . openai ( model = "gpt-3.5-turbo" )

@ gpt_35 . experimental . chat
class CalculatorBot :
    """
    You a calculator bot,
    given a request, you will return the result of the calculation
    """

    def send ( self , message : str ) -> int : ...


calc_bot = CalculatorBot ()
calc_bot . send ( message = "1 + 1" )

>> > 2

Eine gründliche Einführung, Funktionen und Best Practices finden Sie in unserer offiziellen Dokumentation und unserem Leitfaden.

Beitragen

Schließen Sie sich unserer Mission an, um eine deklarative KI noch besser zu machen! Schauen Sie sich unseren Beitragsführer an, um loszulegen.