vectorflow

การไหลเวียนของเวกเตอร์

โอเพ่นซอร์ส, ท่อส่งข้อมูลสูง, การฝังเวกเตอร์ความผิดพลาด

จุดสิ้นสุด API อย่างง่ายที่นำข้อมูลดิบจำนวนมากกระบวนการกระบวนการและเก็บหรือส่งคืนเวกเตอร์อย่างรวดเร็วและน่าเชื่อถือ

เข้าร่วม Discord ของเรา | เว็บไซต์ | ติดต่อกลับ | เอกสาร | เวอร์ชันโฮสต์ฟรี

การแนะนำ

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

เวอร์ชันปัจจุบันนี้เป็น MVP เราขอแนะนำให้ใช้กับ Kubernetes ในการผลิต (ดูรายละเอียดด้านล่าง) สำหรับไฟล์ที่ใช้ข้อความนั้นรองรับ TXT, PDF, HTML และ DOCX

เรียกใช้ในพื้นที่

ด้วยสามคำสั่งคุณสามารถเรียกใช้ Vectorflow ในเครื่อง:

 git clone https://github.com/dgarnitz/vectorflow.git
cd vectorflow
./setup.sh

ฝังเอกสารกับลูกค้า

ในการเริ่มต้นการฝังเอกสารในเครื่องให้ติดตั้งไลบรารี Python ไคลเอนต์ VectorFlow ในสภาพแวดล้อมเสมือนจริงของแอปพลิเคชัน Python ของคุณ

 pip install vectorflow-client

จากนั้นเรียกใช้สิ่งต่อไปนี้

 from vectorflow-client.client.vectorflow import Vectorflow

vectorflow = Vectorflow()
vectorflow.embeddings_api_key = os.getenv("OPEN_AI_KEY")
paths = ['path_to_your_file1', 'path_to_your_file2', ...]
response = vectorflow.upload(paths)

คุณ ไม่ จำเป็นต้องโคลน vectorflow repo เพื่อใช้ประโยชน์จากการทำงานของลูกค้าผ่าน PIP สำหรับคำแนะนำเพิ่มเติมโปรดดู README.md ในไดเรกทอรี client

ดูภาคผนวกสำหรับรายละเอียดเกี่ยวกับวิธีการใช้สคริปต์ testing_clients

นักเทียบท่า

วิธีที่ดีที่สุดในการเรียกใช้ VectorFlow คือผ่าน docker compose หากคุณใช้งานนี้บน Mac โปรดให้สิทธิ์ Docker เพื่ออ่านจากโฟลเดอร์เอกสารของคุณตามคำแนะนำที่นี่ หากสิ่งนี้ล้มเหลวให้ลบส่วน volume ออกจาก docker-compose.yml

1) ตั้งค่าตัวแปรสภาพแวดล้อม

ก่อนอื่นสร้างโฟลเดอร์ env_scripts ในรูทสำหรับตัวแปรสภาพแวดล้อมทั้งหมดจากนั้นสร้าง env_vars.env ในโฟลเดอร์ env_scripts เพื่อเพิ่มตัวแปรสภาพแวดล้อมทั้งหมดที่กล่าวถึงด้านล่าง คุณจะต้องตั้งค่าตัวแปร LOCAL_VECTOR_DB หากคุณใช้งาน Qdrant, Milvus หรือ Weaviate ในเครื่อง

 INTERNAL_API_KEY=your-choice
POSTGRES_USERNAME=postgres
POSTGRES_PASSWORD=your-choice
POSTGRES_DB=vectorflow
POSTGRES_HOST=postgres
RABBITMQ_USERNAME=guest
RABBITMQ_PASSWORD=guest
RABBITMQ_HOST=rabbitmq
LOCAL_VECTOR_DB=qdrant | weaviate
API_STORAGE_DIRECTORY=/tmp
MINIO_ACCESS_KEY=minio99
MINIO_SECRET_KEY=minio123
MINIO_ENDPOINT=minio:9000
MINIO_BUCKET=vectorflow

คุณสามารถเลือกตัวแปรสำหรับ INTERNAL_API_KEY , POSTGRES_PASSWORD และ POSTGRES_DB แต่ต้องตั้งค่า

2) เรียกใช้ Compose Docker

ตรวจสอบให้แน่ใจว่าคุณดึง Rabbit MQ, postgres, min.io เข้าไปใน repo นักเทียบท่าในพื้นที่ของคุณ นอกจากนี้เรายังขอแนะนำให้เรียกใช้ DB เวกเตอร์ในพื้นที่ดังนั้นอย่าลืมดึงภาพของภาพที่คุณใช้ ไฟล์ docker-compose ของเราจะหมุน Qdrant โดยค่าเริ่มต้นและสร้างดัชนี/คอลเลกชันสองตัว หากคุณวางแผนที่จะเรียกใช้ Milvus หรือทอคุณจะต้องกำหนดค่าด้วยตัวคุณเอง

 docker pull rabbitmq
docker pull postgres
docker pull qdrant/qdrant | docker pull semitechnologies/weaviate
docker pull minio/minio

จากนั้นเรียกใช้:

 docker-compose build --no-cache
docker-compose up -d

โปรดทราบว่าคอนเทนเนอร์ init กำลังเรียกใช้สคริปต์ที่ตั้งค่าสคีมาฐานข้อมูล, การจัดเก็บ Object Vector DB และ min.io คอนเทนเนอร์เหล่านี้หยุดหลังจากสคริปต์เสร็จสิ้น สำหรับ Qdrant ตรวจสอบให้แน่ใจว่าได้ดึงเวอร์ชัน 1.9.1 เนื่องจากเป็นเวอร์ชันที่แพ็คเกจ Python ไคลเอนต์ Qdrant ควรทำงานด้วย

ใช้ vectorflow

วิธีที่ดีที่สุดในการใช้ VectorFlow คือกับไคลเอนต์ Python

หากต้องการใช้ VectorFlow เพื่อการพัฒนาให้ทำการร้องขอ HTTP ไปยัง URL ของ API ของคุณ - ตัวอย่างเช่น localhost:8000 จากเครื่องพัฒนาของคุณหรือ vectorflow_api:8000 จากภายในคอนเทนเนอร์ Docker อื่น

คำขอและการตอบกลับ

คำขอทั้งหมดต้องใช้ส่วนหัว HTTP พร้อมคีย์ Authorization ซึ่งเหมือนกับ INTERNAL_API_KEY env var ที่คุณกำหนดไว้ก่อนหน้านี้ (ดูด้านบน) คุณต้องผ่านคีย์ API ฐานข้อมูล Vector ของคุณด้วย HTTP Header X-VectorDB-Key หากคุณกำลังเชื่อมต่อกับอินสแตนซ์บนคลาวด์ของ DB เวกเตอร์และปุ่ม Embedding API กับ X-EmbeddingAPI-Key หากคุณใช้ OpenAI . HuggingFace Sentence Transformer Embeddings ไม่จำเป็นต้องใช้คีย์ API แต่คุณต้องทำตามขั้นตอนข้างต้นเพื่อเรียกใช้คอนเทนเนอร์ด้วยโมเดลที่คุณต้องการ

ปัจจุบัน VectorFlow รองรับฐานข้อมูลเวกเตอร์ Pinecone, Qdrant และ Weaviate Vector

ฝังไฟล์เดียว

หากต้องการส่งไฟล์เดียวสำหรับการฝังให้ทำการร้องขอ POST ไปยังจุดสิ้นสุด /embed ด้วยไฟล์ที่แนบมาส่วนหัว 'Content-Type: multipart/form-data' ต่อไปนี้: payload ต่อไปนี้:

 {
    'SourceData=path_to_txt_file'
    'LinesPerBatch=4096'
    'EmbeddingsMetadata={
        "embeddings_type": "OPEN_AI",
        "chunk_size": 512,
        "chunk_overlap": 128,
        "chunk_strategy": "EXACT | PARAGRAPH | SENTENCE | CUSTOM",
        "model": "text-embedding-3-small | text-embedding-3-large | text-embedding-ada-002"
    }'
    'VectorDBMetadata={
        "vector_db_type": "PINECONE | QDRANT | WEAVIATE",
        "index_name": "index_name",
        "environment": "env_name"
    }'
    'DocumentID=your-optional-internal-tracking-id'
}

สิ่งนี้จะสร้าง job และคุณจะได้รับน้ำหนักบรรทุกต่อไปนี้:

 {
    'message': f"Successfully added {batch_count} batches to the queue",
    'JobID': job_id
}

ตอนนี้จุดสิ้นสุดนี้รองรับการอัปโหลดไฟล์เดียวในแต่ละครั้งสูงสุด 25 MB เนื่องจากปัญหาการหมดเวลา โปรดทราบว่าอาจเลิกใช้แล้ว

ฝังหลายไฟล์พร้อมกัน

หากต้องการส่งหลายไฟล์สำหรับการฝังให้ทำคำขอ POST ไปยังจุดสิ้นสุด /jobs น้ำหนักบรรทุกเหมือนกับการฝังไฟล์เดียวยกเว้นวิธีที่คุณแนบหลายไฟล์แตกต่างกัน:

 {
    'files=[
        ('file',  ('test_pdf.pdf', open(file1_path, 'rb'), 'application/octet-stream')),
        ('file', ('test_medium_text.txt', open(file2_path, 'rb'), 'application/octet-stream'))
    ]'
}

หมายเหตุ: คุณต้อง stream ไฟล์ไปยังจุดสิ้นสุดอย่าส่งเป็นคำขอโพสต์ทั่วไปหรือจะล้มเหลว

จุดสิ้นสุดนี้จะสร้างหนึ่ง job ต่อไฟล์ที่อัปโหลด คุณจะได้รับ Payload JSON ต่อไปนี้:

 {   
    'successful_uploads': successfully_uploaded_files,
    'failed_uploads': failed_uploads,
    'empty_files_count': empty_files_count,
    'duplicate_files_count': duplicate_files_count
}

ในกรณีที่ successfully_uploaded_files เป็นรายการของ tuples ที่มี (file name, job id) และ failed_uploads เป็นรายการชื่อไฟล์ที่ไม่สามารถอัปโหลดเพื่อให้คุณสามารถลองใหม่ได้

รับสถานะงานเดียว

หากต้องการตรวจสอบสถานะของ job ให้ขอ GET ขอไปยังจุดสิ้นสุดนี้: /jobs/<int:job_id>/status การตอบสนองจะอยู่ในรูปแบบ:

 {
    'JobStatus': job_status
}

รับสถานะงานหลายรายการ

หากต้องการตรวจสอบสถานะของ job ทวีคูณให้ทำคำขอ POST ไปยังจุดสิ้นสุดนี้: /jobs/status ร่างกายคำขอจะอยู่ในรูปแบบ:

 {
    'JobIDs': job_ids
}

และการตอบสนองจะอยู่ในรูปแบบ

 {
    'Jobs': [{'JobID': job_id, 'JobStatus': job_status}, ...]}

มีตัวอย่างใน testing_clients/get_jobs_by_ids.py

สคีมามาตรฐานฐานข้อมูลเวกเตอร์

VectorFlow บังคับใช้สคีมามาตรฐานสำหรับการอัปโหลดข้อมูลไปยังร้านค้าเวกเตอร์:

 id: string
source_data: string
source_document: string
embeddings: float array

ID สามารถใช้สำหรับการขจัดข้อมูลซ้ำซ้อนและ idempotency โปรดทราบว่า Weaviate ID เรียกว่า vectorflow_id

เราวางแผนที่จะคิดค้นสิ่งนี้ใน futuer ใกล้เพื่อรองรับการตรวจจับแบบไดนามิกและ/หรือ schemas ที่กำหนดค่าได้ตามถนน

chunking schema & chunking ที่กำหนดเอง

Vectorflow ในตัว chunkers นับโดยโทเค็นไม่ใช่ตัวละคร chunk ในเวกเตอร์โฟลว์เป็นพจนานุกรมที่มีคีย์ต่อไปนี้:

 text: str
vector: list[float]

คุณสามารถเรียกใช้ chunker ที่กำหนดเองโดยการเพิ่มไฟล์ custom_chunker.py ด้วยวิธีการ chunker(source_data: list[str]) ไปยังไดเรกทอรี src/worker ก่อนที่จะสร้างภาพนักเทียบท่าสำหรับคนงาน chunker นี้จะต้องส่งคืนรายการพจนานุกรม chunk ที่สอดคล้องกับมาตรฐานด้านบน

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

webhook embeddings ดิบ

หากคุณต้องการใช้ vectorflow สำหรับ chunking และสร้าง embeddings ให้ผ่านพารามิเตอร์ WebhookURL ในร่างกายของคำขอ /embed และ X-Webhook-Key เป็นส่วนหัว VectorFlow ถือว่าจำเป็นต้องใช้คีย์ WebHook สำหรับการเขียนกลับไปยังจุดสิ้นสุดใด ๆ Embeddings จะถูกส่งกลับพร้อมกับชิ้นส่วนต้นฉบับในพจนานุกรม chunk ที่ระบุไว้ข้างต้น สิ่งนี้ถูกส่งเป็น JSON ด้วยแบบฟอร์มต่อไปนี้:

 {
    'Embeddings': list[dict],
    'DocumentID': str,
    'JobID': int
}

webhook การตรวจสอบความถูกต้อง

หากคุณต้องการตรวจสอบว่าคุณต้องการฝังชิ้นใดให้ส่งพารามิเตอร์ ChunkValidationURL ในร่างกายของคำขอ /embed สิ่งนี้จะส่งคำขอพร้อมเพย์โหลด JSON ต่อไปนี้ {"chunks": chunked_data} โดยที่ chunked_data เป็นรายการของพจนานุกรม chunk มันจะคาดว่าจะกลับ JSON ที่มีคีย์ valid_chunks พร้อมรายการชิ้นส่วนที่ถูกต้องสำหรับการฝัง จุดสิ้นสุดนี้จะหมดเวลาหลังจาก 30 วินาทีโดยค่าเริ่มต้น แต่สามารถกำหนดค่าได้ในรหัสแอปพลิเคชัน

ปลายทาง S3

VectorFlow ถูกรวมเข้ากับ AWS S3 คุณสามารถผ่าน URL S3 ที่ลงนามล่วงหน้าในร่างกายของ HTTP แทนไฟล์ ใช้ฟิลด์ฟอร์ม PreSignedURL และกดจุดสิ้นสุด /s3 จุดสิ้นสุดนี้มีการกำหนดค่าและข้อ จำกัด เดียวกันกับจุดสิ้นสุด /embed

telemetry

VectorFlow ใช้ Posthog เพื่อรวบรวมข้อมูลเกี่ยวกับการใช้งานโดยไม่ระบุชื่อ สิ่งนี้ไม่ได้รวบรวมข้อมูลที่สามารถระบุตัวบุคคลได้ หากคุณต้องการปิดการใช้งานให้เพิ่มตัวแปรสภาพแวดล้อมต่อไปนี้ลงใน env_vars.env ของคุณ:

 TELEMETRY_DISABLED=True

Kubernetes

คุณสามารถเรียกใช้ VectorFlow ได้ใน Kubernetes ด้วย minikube โดยใช้ ./kube/scripts/deploy-local-k8s.sh ซึ่งจะใช้ไฟล์ YAML ทั้งหมดที่อยู่ใน kube/ สคริปต์นี้จะไม่ทำงานหากคุณยังไม่ได้ติดตั้ง Docker, Minikube และ Kubectl

สคริปต์นี้จะสร้างภาพในเครื่องก่อนจากนั้นถ่ายโอนไปยัง minikube หากคุณต้องการตรวจสอบว่ามีภาพใดบ้างใน minikube ให้เรียกใช้สิ่งต่อไปนี้:

 eval $(minikube docker-env)
docker images

คุณจะต้องเรียกใช้ minikube tunnel เพื่อเข้าถึงทรัพยากรที่อยู่ในคลัสเตอร์จากเครื่องพัฒนาของคุณ สคริปต์การตั้งค่าจะโหลดภาพจากบริบทของนักเทียบท่าในพื้นที่ของคุณไปยัง Minikube

คุณสามารถใช้ไฟล์ YAML ใน kube/ เป็นพื้นฐานสำหรับการปรับใช้การผลิต แต่คุณจะต้องปรับแต่งตามความต้องการของคลัสเตอร์เฉพาะของคุณเล็กน้อย ติดต่อเราหากคุณต้องการความช่วยเหลือ

การบริจาค

เรารักข้อเสนอแนะจากชุมชน หากคุณมีความคิดว่าจะทำให้โครงการนี้ดีขึ้นได้อย่างไรเราขอแนะนำให้คุณเปิดปัญหาหรือเข้าร่วม Discord ของเรา กรุณาติดแท็ก dgarnitz และ danmeier2

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

โปรดติดแท็ก dgarnitz ใน PRs ทั้งหมดและ อัปเดต readme เพื่อสะท้อนการเปลี่ยนแปลงของคุณ

การทดสอบ

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

 python -m unittest module.tests.test_file.TestClass.test_method

ในการเรียกใช้การทดสอบทั้งหมดในการใช้ไฟล์:

 python -m unittest module.tests.test_file

สำหรับการทดสอบแบบ end-to-end ขอแนะนำให้สร้างและเรียกใช้โดยใช้ Docker-compose แต่นำคอนเทนเนอร์ที่คุณกำลังแก้ไขและเรียกใช้ในเครื่องบนเครื่องพัฒนาของคุณ สิ่งนี้จะหลีกเลี่ยงความจำเป็นในการสร้างภาพใหม่อย่างต่อเนื่องและเรียกใช้คอนเทนเนอร์อีกครั้ง ตรวจสอบให้แน่ใจว่าได้เปลี่ยนตัวแปรสภาพแวดล้อมในเทอร์มินัลเครื่องพัฒนาของคุณเป็นค่าที่ถูกต้อง (เช่น localhost แทน rabbitmq หรือ postgres ) เพื่อให้คอนเทนเนอร์ Docker สามารถสื่อสารกับเครื่องพัฒนาของคุณได้ เมื่อใช้งานได้ในพื้นที่คุณสามารถทำการทดสอบขั้นสุดท้ายกับทุกสิ่งใน Docker-compose

การยืนยัน

โปรดตรวจสอบว่าการเปลี่ยนแปลงทั้งหมดทำงานร่วมกับนักเทียบท่าก่อนที่จะเปิดการประชาสัมพันธ์

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

แผนงาน

• สนับสนุนการบริโภคข้อมูลไดเรกทอรีหลายไฟล์จากแหล่งต่าง ๆ เช่น Salesforce, Google Drive และอื่น ๆ
• กลไกการลองใหม่
• การบูรณาการ Langchain
• สนับสนุนการโทรกลับสำหรับการเขียนข้อมูลเมตาวัตถุไปยังร้านค้าแยกต่างหาก
• สคีมา DB เวกเตอร์ที่กำหนดค่าได้แบบไดนามิก
• ความสามารถในการขจัดข้อมูลซ้ำซ้อน
• การควบคุมเวอร์ชันเวกเตอร์
• "ฉลาด" chunker
• "สมาร์ท" เมตาดาต้าสกัด

ภาคผนวก

ฝังด้วยสคริปต์การทดสอบ

วิธีที่ง่ายอย่างหนึ่งในการใช้ VectorFlow คือกับไคลเอนต์การทดสอบของเราซึ่งอยู่ใน testing_clients/ Directory มีหลายสคริปต์ที่มีการกำหนดค่าที่แตกต่างกันสำหรับข้อมูลการอัปโหลด Qickly เรา recommmend เริ่มต้นด้วย testing_clients/standard_upload_client.py - การเรียกใช้สคริปต์นี้จะส่งเอกสารเดียวไปยัง VectorFlow เพื่อฝังด้วย AI ADA เปิดและอัปโหลดไปยังอินสแตนซ์ QDRANT ท้องถิ่น คุณสามารถเปลี่ยนค่าเพื่อให้ตรงกับการกำหนดค่าของคุณ ในการอัปโหลดหลายไฟล์พร้อมกันให้ใช้ testing_clients/streaming_upload_client.py

โปรดทราบว่าตัวแปร TESTING_ENV นั้นเทียบเท่ากับฟิลด์ environment ใน VectorDBMetadata ซึ่งสอดคล้องกับสภาพแวดล้อมใน Pincone คลาสใน Weaviate คอลเลกชันใน Qdrant ฯลฯ ไดเรกทอรี testing_clients มีสคริปต์ตัวอย่างที่คุณสามารถติดตามเพื่อเรียกใช้ Vectorflow เพิ่มปุ่มฝังและฐานข้อมูลของคุณลงในสคริปต์ env_scrips/env_vars.sh ที่สร้างขึ้นและตั้งค่าตัวแปร filepath ใน testing_clients/standard_upload_client.py เพื่อชี้ไปที่ไฟล์ที่คุณต้องการฝัง จากนั้นเรียกใช้:

 source env_scrips/env_vars.sh
python testing-clients/standard_upload_client.py

ในการอัปโหลดหลายไฟล์พร้อมกันให้ใช้ testing_clients/streaming_upload_client.py

ดูด้านบนสำหรับคำอธิบายโดยละเอียดเพิ่มเติมเกี่ยวกับวิธีการตั้งค่าและกำหนดค่าระบบด้วยตนเอง โปรดทราบว่าสคริปต์ setup จะไม่สร้างสภาพแวดล้อมการพัฒนาบนเครื่องของคุณมันตั้งค่าและเรียกใช้งาน Docker-compose เท่านั้น เราไม่แนะนำให้ใช้ VectorFlow บน Windows

ขอ

ในการดำเนินการค้นหาส่งคำขอ POST ไปที่ /images/search 'Content-Type: multipart/form-data'

 {
    'ReturnVectors': boolean,
    'TopK': integer, less than 1000,
    'VectorDBMetadata={
        "vector_db_type": "PINECONE | QDRANT | WEAVIATE",
        "index_name": "index_name",
        "environment": "env_name"
    }'
}

คำขอทั้งหมดต้องการส่วนหัว HTTP พร้อมคีย์ Authorization ซึ่งเหมือนกับ INTERNAL_API_KEY env var ที่คุณกำหนดไว้ก่อนหน้านี้ (ดูด้านบน) คุณต้องผ่านคีย์ API ฐานข้อมูล Vector ของคุณด้วย HTTP Header X-VectorDB-Key หากคุณกำลังเชื่อมต่อกับอินสแตนซ์บนคลาวด์ของ DB เวกเตอร์

การตอบสนอง

การค้นหาความคล้ายคลึงกันของภาพจะส่งคืนวัตถุตอบกลับที่มีการจับคู่ k ด้านบนรวมถึงเวกเตอร์ดิบหากมีการร้องขอด้วยแบบฟอร์มต่อไปนี้:

 {
    "similar_images": list of match objects
    "vectors": list of list of floats
}

โดยที่วัตถุ `match`` ถูกกำหนดเป็น:

 {
    "id": str,
    "score": float,
    "metadata": {"source_document" : str}
}

การสร้างภาพแต่ละภาพด้วยคำสั่ง Docker

หากคุณต้องการใช้ docker build และ docker run เพื่อสร้างและ docker-compose ใช้ภาพแต่ละภาพแทนที่จะทำตามขั้นตอนเหล่านี้:

1. cd src/
2. docker build --file api/Dockerfile -t vectorflow_api:latest . เพื่อสร้าง - อย่าลืมช่วงเวลาในตอนท้าย
3. docker run --network=vectorflow --name=vectorflow_api -d --env-file=../env_scripts/env_vars.env -p 8000:8000 vectorflow_api:latest ที่จะเรียกใช้ API คุณไม่ต้องการอาร์กิวเมนต์พอร์ตเพื่อเรียกใช้คนงาน