Mixedbread Cloud: Eine einheitliche API für Lag -Pipelines

pip set up mixedbread openai

import os
import time
from mixedbread import Mixedbread
from openai import OpenAI

# --- Configuration ---
# 1. Get your Mixedbread API Key
mxbai_api_key = os.getenv("MXBAI_API_KEY")

# 2. Get your OpenAI API Key
openai_api_key = os.getenv("OPENAI_API_KEY")

# 3. Outline the trail to the FOLDER containing your PDF recordsdata
pdf_folder_path = "/work/docs"

# 4. Vector Retailer Configuration
vector_store_name = "Abid Articles"

# 5. OpenAI Mannequin Configuration
openai_model = "gpt-4.1-nano-2025-04-14"

# --- Initialize Shoppers ---
mxbai = Mixedbread(api_key=mxbai_api_key)
openai_client = OpenAI(api_key=openai_api_key)

import glob

pdf_files_to_upload = glob.glob(os.path.be part of(pdf_folder_path, "*.pdf")) # Discover all .pdf recordsdata

print(f"Discovered {len(pdf_files_to_upload)} PDF recordsdata to add:")
for pdf_path in pdf_files_to_upload:
    print(f"  - {os.path.basename(pdf_path)}")

uploaded_file_ids = ()
print("nUploading recordsdata...")
for pdf_path in pdf_files_to_upload:
    filename = os.path.basename(pdf_path)
    print(f"  Importing {filename}...")
    with open(pdf_path, "rb") as f:
        upload_response = mxbai.recordsdata.create(file=f)
        file_id = upload_response.id
        uploaded_file_ids.append(file_id)
        print(f"    -> Uploaded efficiently. File ID: {file_id}")

print(f"nSuccessfully uploaded {len(uploaded_file_ids)} recordsdata.")

Discovered 4 PDF recordsdata to add:
  - Constructing Agentic Software utilizing Streamlit and Langchain.pdf
  - Deploying DeepSeek Janus Professional domestically.pdf
  - Tremendous-Tuning GPT-4o.pdf
  - Methods to Attain $500k on Upwork.pdf

Importing recordsdata...
  Importing Constructing Agentic Software utilizing Streamlit and Langchain.pdf...
    -> Uploaded efficiently. File ID: 8a538aa9-3bde-4498-90db-dbfcf22b29e9
  Importing Deploying DeepSeek Janus Professional domestically.pdf...
    -> Uploaded efficiently. File ID: 52c7dfed-1f9d-492c-9cf8-039cc64834fe
  Importing Tremendous-Tuning GPT-4o.pdf...
    -> Uploaded efficiently. File ID: 3eaa584f-918d-4671-9b9c-6c91d5ca0595
  Importing Methods to Attain $500k on Upwork.pdf...
    -> Uploaded efficiently. File ID: 0e47ba93-550a-4d4b-9da1-6880a748402b

Efficiently uploaded 4 recordsdata.

vector_store_response = mxbai.vector_stores.create(
    title=vector_store_name,
    file_ids=uploaded_file_ids # Add all uploaded file IDs throughout creation
)
vector_store_id = vector_store_response.id

print("nMonitoring file processing standing (this may occasionally take a while)...")
all_files_processed = False
max_wait_time = 600 # Most seconds to attend (10 minutes, regulate as wanted)
check_interval = 20 # Seconds between checks
start_time = time.time()
final_statuses = {}

whereas not all_files_processed and (time.time() - start_time) < max_wait_time:
    all_files_processed = True # Assume true for this test cycle
    current_statuses = {}
    files_in_progress = 0
    files_completed = 0
    files_failed = 0
    files_pending = 0
    files_other = 0

    for file_id in uploaded_file_ids:
       
        status_response = mxbai.vector_stores.recordsdata.retrieve(
            vector_store_id=vector_store_id,
            file_id=file_id
        )
        current_status = status_response.standing
        final_statuses(file_id) = current_status # Retailer the newest standing

        if current_status == "accomplished":
            files_completed += 1
        elif current_status in ("failed", "cancelled", "error"):
            files_failed += 1
        elif current_status == "in_progress":
            files_in_progress += 1
            all_files_processed = False # A minimum of one file remains to be processing
        elif current_status == "pending":
             files_pending += 1
             all_files_processed = False # A minimum of one file hasn't began
        else:
            files_other += 1
            all_files_processed = False # Unknown standing, assume not achieved

    print(f"  Standing Verify (Elapsed: {int(time.time() - start_time)}s): "
          f"Accomplished: {files_completed}, Failed: {files_failed}, "
          f"In Progress: {files_in_progress}, Pending: {files_pending}, Different: {files_other} "
          f"/ Complete: {len(uploaded_file_ids)}")

    if not all_files_processed:
        time.sleep(check_interval)

# --- Verify Remaining Processing Consequence ---
completed_count = sum(1 for standing in final_statuses.values() if standing == 'accomplished')
failed_count = sum(1 for standing in final_statuses.values() if standing in ('failed', 'cancelled', 'error'))

print("n--- Processing Abstract ---")
print(f"Complete recordsdata processed: {len(final_statuses)}")
print(f"Efficiently accomplished: {completed_count}")
print(f"Failed or Cancelled: {failed_count}")
for file_id, standing in final_statuses.gadgets():
    if standing != 'accomplished':
        print(f"  - File ID {file_id}: {standing}")

if completed_count == 0:
     print("nNo recordsdata accomplished processing efficiently. Exiting RAG pipeline.")
     exit()
elif failed_count > 0:
     print("nWarning: Some recordsdata failed processing. RAG will proceed utilizing solely the efficiently processed recordsdata.")
elif not all_files_processed:
     print(f"nWarning: File processing didn't full for all recordsdata throughout the most wait time ({max_wait_time}s). RAG will proceed utilizing solely the efficiently processed recordsdata.")

Monitoring file processing standing (this may occasionally take a while)...
  Standing Verify (Elapsed: 0s): Accomplished: 0, Failed: 0, In Progress: 4, Pending: 0, Different: 0 / Complete: 4
  Standing Verify (Elapsed: 21s): Accomplished: 0, Failed: 0, In Progress: 4, Pending: 0, Different: 0 / Complete: 4
  Standing Verify (Elapsed: 42s): Accomplished: 4, Failed: 0, In Progress: 0, Pending: 0, Different: 0 / Complete: 4

--- Processing Abstract ---
Complete recordsdata processed: 4
Efficiently accomplished: 4
Failed or Cancelled: 0

user_query = "Methods to Deploy Deepseek Janus Professional?"

retrieved_context = ""

search_results = mxbai.vector_stores.search(
    vector_store_ids=(vector_store_id), # Search inside our newly created retailer
    question=user_query,
    top_k=10 # Retrieve high 10 related chunks throughout all paperwork
)

if search_results.information:
    # Mix the content material of the chunks right into a single context string
    context_parts = ()
    for i, chunk in enumerate(search_results.information):
        context_parts.append(f"Chunk {i+1} from '{chunk.filename}' (Rating: {chunk.rating:.4f}):n{chunk.content material}n---")
    retrieved_context = "n".be part of(context_parts)
else:
    retrieved_context = "No context was retrieved." 

prompt_template = f"""
You might be an assistant answering questions primarily based *solely* on the supplied context from a number of paperwork.
Don't use any prior data. If the context doesn't comprise the reply to the query, state that clearly.

Context from the paperwork:
---
{retrieved_context}
---

Query: {user_query}

Reply:
"""

response = openai_client.chat.completions.create(
    mannequin=openai_model,
    messages=(
        {"position": "consumer", "content material": prompt_template}
    ),
    temperature=0.2,
    max_tokens=500
)

final_answer = response.decisions(0).message.content material.strip()

print(final_answer)

To deploy DeepSeek Janus Professional domestically, comply with these steps:

1. Set up Docker Desktop from https://www.docker.com/ and set it up with default settings. On Home windows, guarantee WSL is put in if prompted.

2. Clone the Janus repository by operating:
   ```
   git clone https://github.com/kingabzpro/Janus.git
   ```
3. Navigate into the cloned listing:
   ```
   cd Janus
   ```
4. Construct the Docker picture utilizing the supplied Dockerfile:
   ```
   docker construct -t janus .
   ```
5. Run the Docker container with the next command, which units up port forwarding, GPU entry, and protracted storage:
   ```
   docker run -it --rm -p 7860:7860 --gpus all --name janus_pro -e TRANSFORMERS_CACHE=/root/.cache/huggingface -v huggingface:/root/.cache/huggingface janus:newest
   ```
6. Watch for the container to obtain the mannequin and begin the Gradio utility. As soon as operating, entry the app at http://localhost:7860/.

7. The appliance has two sections: one for picture understanding and one for picture era, permitting you to add photographs, ask for descriptions or poems, and generate photographs primarily based on prompts.

This course of lets you deploy DeepSeek Janus Professional domestically in your machine.