synth_machine

Mesin synth

Agen AI adalah mesin negara bukan DAGS

Mesin Synth memungkinkan pengguna membuat dan menjalankan mesin status agen AI ( Synth ) dengan memberikan SynthDefinition untuk mendefinisikan alur kerja AI terstruktur.
Mesin negara adalah konstruksi yang kuat karena memungkinkan ahli domain untuk mendekonstruksi masalah menjadi set negara bagian dan transisi.
Transisi antar negara kemudian dapat memanggil LLM, alat, proses data atau campuran banyak output.

Instalasi

Model API

Instal paket. pip install synth_machine[openai,togetherai,anthropic] atau poetry add synth_machine[openai,togetherai,anthropic]

Tambahkan Siapkan Kunci Lingkungan Penyedia API Anda

 # You only need to set the API providers you want to use.
export OPENAI_API_KUY=secret
export ANTHROPIC_API_KEY=secret
export TOGETHER_API_KEY=secret

(Segera) model lokal

pip install synth_machine[vllm,llamacpp] atau poetry add synth_machine[vllm,llamacpp]

Anda mungkin perlu mengatur CUDA, VLLM atau LLAMA.CPP untuk penggunaan lokal.

Tautan yang bermanfaat:

• https://docs.vllm.ai/en/latest/getting_started/installation.html
• https://developer.nvidia.com/cuda-toolkit
• https://github.com/ggerganov/llama.cpp

Tentukan synth

 agent = Synth(
    config: dict[SynthDefinition], # Synth state machine defining states, transitions and prompts.
    tools=[], # List of tools the agent will use
    memory={}, # Any existing memory to add on top of any model_config.initial_memory
    rag_runner: Optional[RAG] = None # Define a RAG integration for your agent.
    postprocess_functions = [] # Any glue code functions
    store : ObjectStore = ObjectStore(":memory:") # Any files created by tools will automatically go to you object store    

SynthDefinition dapat ditemukan di SynthDefinition Docs atau synth_machine/synth_definition.py. Basemodel Pydantic yang membentuk SynthDefinition akan menjadi representasi Synth yang paling akurat.
Kami berharap spesifikasi memiliki pembaruan antara versi utama.

Status agen dan kemungkinan pemicu

Di titik mana pun, Anda dapat memeriksa keadaan saat ini dan pemicu berikutnya

 # Check state
agent.current_state()

# Triggers
agent.interfaces_for_available_triggers()

Jalankan synth

Kelompok

 await agent.trigger(
    "[trigger_name]",
    params={
        "input_1": "hello"
    }
)

Panggilan transisi batch akan menghasilkan setiap variabel output yang dihasilkan dalam transisi itu.

Mengalir

 await agent.streaming_trigger(
    "[trigger_name]",
    params={
        "input_1": "hello"
    }
)

Respons streaming menghasilkan salah satu peristiwa berikut:

 class YieldTasks(StrEnum):
    CHUNK = "CHUNK"
    MODEL_CONFIG = "MODEL_CONFIG"
    SET_MEMORY = "SET_MEMORY"
    SET_ACTIVE_OUTPUT = "SET_ACTIVE_OUTPUT"

• CHUNK : Generasi LLM dikirim oleh potongan satu token pada satu waktu.
• MODEL_CONFIG : Menghasilkan pelaksana mana yang saat ini digunakan untuk antarmuka frontend spesifik penyedia.
• SET_MEMORP : Mengirim acara mengatur variabel memori baru
• SET_ACTIVE_OUTPUT : menghasilkan pemicu output transisi saat ini.

Ini memungkinkan pengguna bereksperimen menggunakan trigger dan kemudian mengintegrasikan ke generasi LLM Stream Waktu Nyata ke pengguna yang menggunakan Events Side Event (SSE) dan trigger_streaming .

Llms

Kami menawarkan beberapa pelaksana untuk menghasilkan penyelesaian obrolan LLM lokal atau API.

Model API

• openai : https://openai.com/api/pricing/
• togetherai : https://docs.together.ai/docs/inference-odels
• anthropic : https://docs.anthropic.com/en/docs/models-overview
• (Segera) google : https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/overview

Lokal (segera)

• VLLM : https://github.com/vllm-project/vllm
• Llama-CPP : https://github.com/ggerganov/llama.cpp

Model Config

Anda dapat menentukan penyedia dan model baik dalam default-model-config dan basis synth atau model_config pada output transisi.

 ModelConfig:
...
executor: [openai|togetherai|anthropic|vllm|llamacpp]
llm_name: [model_name]

Ingatan

Memori agen adalah kamus yang berisi semua variabel sementara yang dibuat di keadaan sebelumnya dan input manusia / sistem.

 agent.memory
# -> {
#   "[memory_key]": [memory_value]
# }

Peralatan

Fungsi postprocess hanya boleh digunakan untuk kode lem dasar, semua fungsi utama harus dibangun menjadi alat.

Alat adalah Restapis dan dapat ditambahkan dengan menyediakan skema API JSON

Pergi ke "./tools/tofuTool/api.py untuk melihat fungsionalitasnya.

Mulai API

 cd tools/tofuTool
poetry install
poetry run uvicorn api:app --port=5001 --reload

Ambil spesifikasi API

 curl -X GET http://localhost:5001/openapi.json > openapi_schema.json

Tentukan alat

Anda dapat mendefinisikan alat seperti itu hanya dengan skema name, API endpoint dan alat OpenAPI.

 tofu_tool = Tool(
    name="tofu_tool",
    api_endpoint="http://localhost:5001",
    api_spec=tool_spec
)

Rag mesin synth

Pengambilan Generasi Augemented adalah alat yang ampuh untuk meningkatkan respons LLM dengan memberikan contoh yang sama secara semantik atau diberikan pada materi yang ingin dihasilkan oleh LLM.

synth_machine secara fleksibel sehingga selama Anda mewarisi dari synth_machine.RAG dan create:

• embed(documents: List[str]) dan
• query(prompt: str, rag_config: Optional[synth_machine.RAGConfig])

Mudah untuk mengintegrasikan beberapa penyedia dan database vektor. Seiring waktu akan ada yang didukung dan implementasi Rag Komunitas di berbagai penyedia embeddings dan database vektor.

Contoh kain qdrant & fastembed

Kelas RAG berikut sangat ideal untuk bereksperimen dengan pengaturan kain lokal di CPU.

 pip install qdrant-client, fastembed

Tentukan kelas kain

 from synth_machine.rag import RAG
from qdrant_client import AsyncQdrantClient
from fastembed import TextEmbedding
from typing import List, Optional
from qdrant_client.models import Distance, VectorParams, PointStruct


class Qdrant(RAG):

    """
    VectorDB: Qdrant - https://github.com/qdrant/qdrant
    Embeddings: FastEmbed - https://github.com/qdrant/fastembed

    This provides fast and lightweight on-device CPU embeddings creation and 
    similarity search using Qdrant in memory.
    """
    
    def __init__(
        self,
        collection_name: str,
        embedding_model: str="BAAI/bge-small-en-v1.5",
        embedding_dimensions: int=384,
        embedding_threads: int=-1,
        qdrant_location: str=":memory:",
    ):
        self.embedding_model = TextEmbedding(
            model_name=embedding_model,
            threads=embedding_threads
        )
        self.embedding_dimensions = embedding_dimensions
        self.qdrant = AsyncQdrantClient(qdrant_location)
        self.collection_name = collection_name
    
    async def create_collection(self) -> bool:
        if await self.qdrant.collection_exists(self.collection_name):
            return True
        else:
            return await self.qdrant.create_collection(
                collection_name=self.collection_name,
                vectors_config=VectorParams(
                    size=self.embedding_dimensions, # maps to 'BAAI/bge-small-en-v1.5' model dimensions
                    distance=Distance.COSINE
                ) 
            )
    
    async def embed(self, documents: List[str], metadata: Optional[List[dict]]=None):
        if metadata and len(documents) != len(metadata):
            raise ValueError("documents and metadata must be the same length")
        embedding_list = list(
            self.embedding_model.embed(documents)
        )
        upsert_response = await self.qdrant.upsert(
            collection_name=self.collection_name,
            points=[
                PointStruct(
                    id=i,
                    vector=list(vector),
                    payload=metadata[i]
                )
                for i, vector in enumerate(embedding_list)
            ]
        )
        return upsert_response.status
        

    async def query(self, prompt: str, rag_config: RAGConfig) -> List[dict]:
        embedding = next(self.embedding_model.embed([prompt]))
            
        similar_responses = await self.qdrant.search(
            collection_name=self.collection_name,
            query_vector=embedding,
            limit=rag_config.n
        )
        return [
            point.payload for point in similar_responses
        ]

Sekarang inisiasi kelas Qdrant dan berikan saat mendefinisikan Synth .

 qdrant = Qdrant(collection_name="tofu_examples")
await qdrant.create_collection()

agent = Synth(
    ...
    rag_runner=Qdrant
)

Toko

Alat dapat mengembalikan berbagai objek yang berbeda. File apa pun yang dibuat oleh alat akan secara otomatis masuk ke agent.store Anda. Store. Kami menggunakan ObjectStore untuk penyimpanan file, dengan ObjectStore(":memory:") sebagai default.

Untuk mengambil file: agent.store.get(file_name)

ObjectStore memungkinkan integrasi yang mudah untuk:

• Toko file lokal
• S3
• GCS
• Biru langit

Contoh toko objek GCS

 from synth_machine.machine import ObjectStore

agent = Agent(
    ...
    store=ObjectStore("gs://[bucket_name]/[prefix]))
)

Fungsi yang ditentukan pengguna

Fungsionalitas khusus dapat didefinisikan sebagai fungsi yang ditentukan pengguna (UDF).
Ini mengambil Synth.memory sebagai input dan memungkinkan Anda menjalankan fungsionalitas khusus sebagai bagian dari synth-machine .

 # Define postprocess function

from synth_machine.user_defined_functions import udf

@udf
def abc_postprocesss(memory):
    ...
    return memory["variable_key"]

agent = Synth(
  ...
  user_defined_functions = {
    "abc": abc_postprocess
  }
)

Contoh konfigurasi transisi udf

 ...
- key: trigger_udf
  inputs:
    - key: variable_key
  outputs:
    - key: example_udf
      udf: abc

Catatan: Fungsionalitas non -sepele harus menjadi alat dan bukan UDF.