Προηγμένα Πρότυπα
Σε αυτήν τη σελίδα
Ενημερώθηκε στις 3 Νοεμβρίου 2026: Το υπο-workflow επέστρεφε προηγουμένως το
execution.output, το οποίο λείπει από το SDKmistralai3.7.0. Το αποτέλεσμα διαβάζεται πλέον από τοresult, χρησιμοποιώνταςwait_for_result=Trueγια αναμονή ολοκλήρωσης.
Πέρα από τα Γραμμικά Workflows
Μέχρι στιγμής, εξετάσαμε workflows που εκτελούν δραστηριότητες διαδοχικά. Στην πράξη, οι πραγματικές περιπτώσεις χρήσης απαιτούν πιο εξελιγμένα πρότυπα: αλυσιδωτή εκτέλεση workflows, παράλληλη εκτέλεση δραστηριοτήτων ή λήψη σύνθετων υπό όρων αποφάσεων. Αυτά τα τέσσερα πρότυπα—αλυσιδωτή εκτέλεση, συνέχιση, παραλληλισμός και fan-out/fan-in—καλύπτουν σχεδόν κάθε αρχιτεκτονική που θα χρειαστείτε ναδομήσετε.
Αλυσιδωτή Εκτέλεση Workflows (Chaining)
Ένα workflow μπορεί να ενεργοποιήσει ένα άλλο workflow. Αυτή η δυνατότητα εξυπηρετεί δύο distinct στόχους: τη διάσπαση σύνθετης λογικής σε επαναχρησιμοποιήσιμα υπο-workflows και την παράκαμψη του ορίου των 51.200 συμβάντων ανά εκτέλεση, καθώς κάθε child workflow διαθέτει δικό του προϋπολογισμό. Ο μηχανισμός βασίζεται σε μια δραστηριότητα, το μοναδικό σημείο όπου το SDK μπορεί νομίμως να πραγματοποιήσει κλήση δικτύου.
import mistralai.workflows as workflows
from mistralai.client import Mistral
@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
"""Launches a child workflow and waits for its result."""
client = Mistral()
execution = await client.workflows.execute_workflow_async(
workflow_identifier=workflow_name,
input=input_data,
wait_for_result=True, # wait for the child workflow result
)
return execution.result
@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
# Step 1: Data collection (dedicated sub-workflow)
data = await launch_sub_workflow(
"data_collection",
{"sources": params["sources"]}
)
# Step 2: Analysis (dedicated sub-workflow)
analysis = await launch_sub_workflow(
"content_analysis",
{"data": data}
)
# Step 3: Report generation (dedicated sub-workflow)
report = await launch_sub_workflow(
"report_generation",
{"analysis": analysis, "format": params["format"]}
)
return report
Το όφελος ξεπερνά την απλή αναγνωσιμότητα: το data_collection γίνεται ένα αυτόνομο workflow, ελέγξιμο μεμονωμένα και επαναχρησιμοποιήσιμο από άλλους αγωγούς, με τις δικές του πολιτικές χρονικού ορίου και επαναλήψεων.
Ο ίδιος μηχανισμός, όταν εφαρμόζεται σε ένα workflow που καλεί τον εαυτό του, δημιουργεί το πρότυπο συνέχισης (continuation). Αντί να επεξεργαστείτε εκατό χιλιάδες στοιχεία σε μία μόνο εκτέλεση—κάτι που απαγορεύεται από το όριο συμβάντων—το workflow επεξεργάζεται μια παρτίδα και αναθέτει τα υπόλοιπα σε ένα νέο instance.
@workflows.workflow.define(name="batch_processing")
class BatchProcessing:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
offset = params.get("offset", 0)
batch_size = 100
# Retrieve the current batch
batch = await retrieve_batch(offset, batch_size)
if not batch["items"]:
# All batches processed
return {"status": "completed", "total_processed": offset}
# Process the current batch
await process_batch(batch["items"])
# Launch the next batch via a new workflow
next_batch = await launch_sub_workflow(
"batch_processing",
{"offset": offset + batch_size}
)
return next_batch
Κάθε νέα εκτέλεση ξεκινά με ένα καθαρό ημερολόγιο. Ο αριθμός των επεξεργάσιμων στοιχείων γίνεται απεριόριστος, με τη συνθήκη τερματισμού να είναι απλώς μια κενή παρτίδα.
Παραλληλισμός με asyncio.gather
Όταν πολλαπλές δραστηριότητες είναι ανεξάρτητες μεταξύ τους, δεν υπάρχει λόγος να εκτελούνται διαδοχικά. Το asyncio.gather τις υποβάλλει στην πλατφόρμα ταυτόχρονα και ο συνολικός χρόνος πλησιάζει εκείνον της πιο αργής δραστηριότητας αντί για το άθροισμα όλων.
import asyncio
import mistralai.workflows as workflows
@workflows.activity()
async def analyze_source(url: str) -> dict:
"""Analyzes a data source."""
async with httpx.AsyncClient() as client:
response = await client.get(url)
return {"url": url, "size": len(response.text)}
@workflows.workflow.define(name="parallel_analysis")
class ParallelAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# Launch all analyses in parallel
results = await asyncio.gather(
*[analyze_source(url) for url in urls]
)
return {
"source_count": len(results),
"results": list(results)
}
Ισχύει όμως μια προειδοποίηση: από προεπιλογή, το gather διαδίδει την πρώτη εξαίρεση που συναντά και ματαιώνει ολόκληρο το σύνολο. Εάν αναλύετε σαράντα εξωτερικές πηγές, το γεγονός ότι μία μόνο είναι εκτός σύνδεσης σας κάνει να χάσετε τις άλλες τριάντα εννέα. Η παράμετρος return_exceptions=True αλλάζει αυτή τη συμπεριφορά: τα σφάλματα επιστρέφονται ως συνηθισμένες τιμές, αφήνοντάς σας να τα διαχειριστείτε.
@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# return_exceptions=True prevents one error from blocking the others
results = await asyncio.gather(
*[analyze_source(url) for url in urls],
return_exceptions=True
)
successes = []
errors = []
for i, result in enumerate(results):
if isinstance(result, Exception):
errors.append({"url": urls[i], "error": str(result)})
else:
successes.append(result)
return {
"successes": successes,
"errors": errors,
"success_rate": len(successes) / len(urls)
}
Αυτό το workflow επιστρέφει ένα μερικό αποτέλεσμα συνοδευόμενο από έναν ρυθμό επιτυχίας, επιτρέποντας στις downstream διαδικασίες να αποφασίσουν εάν η ποιότητα είναι επαρκής ή εάν απαιτείται επανάληψη.
Λήψη Αποφάσεων στο Workflow
Η σύνθετη διακλάδωση όχι μόνο επιτρέπεται, αλλά συχνά αποτελεί τον κύριο λόγο χρήσης workflows, υπό την προϋπόθεση ότι οι συνθήκες προέρχονται από αποτελέσματα δραστηριοτήτων. Η περίπτωση moderation περιεχομένου απεικονίζει καλά αυτή τη λογική καταρράκτη: αυτόματη απόφαση όταν το μοντέλο είναι εξαιρετικά σίγουρο, δεύτερη γνώμη όταν η βεβαιότητα είναι μέτρια και κλιμάκωση σε ανθρώπινο παράγοντα σε περίπτωση διαφωνίας ή χαμηλής βεβαιότητας.
@workflows.workflow.define(name="content_moderation")
class ContentModeration:
@workflows.workflow.entrypoint
async def run(self, content: dict) -> dict:
# Step 1: Automatic analysis
analysis = await auto_analyze_content(content["text"])
if analysis["confidence_score"] > 0.95:
# High confidence: automatic decision
if analysis["category"] == "acceptable":
await publish_content(content["id"])
return {"decision": "published", "method": "automatic"}
else:
await reject_content(content["id"], analysis["reason"])
return {"decision": "rejected", "method": "automatic"}
elif analysis["confidence_score"] > 0.7:
# Moderate confidence: second analysis with a different model
second_analysis = await analyze_content_model_b(content["text"])
if analysis["category"] == second_analysis["category"]:
# Both models agree
if analysis["category"] == "acceptable":
await publish_content(content["id"])
return {"decision": "published", "method": "ai_consensus"}
else:
await reject_content(content["id"], analysis["reason"])
return {"decision": "rejected", "method": "ai_consensus"}
else:
# Disagreement: human escalation
await escalate_moderation(content["id"], analysis, second_analysis)
return {"decision": "pending", "method": "human_escalation"}
else:
# Low confidence: direct escalation
await escalate_moderation(content["id"], analysis, None)
return {"decision": "pending", "method": "human_escalation"}
Παρατηρήστε το πεδίο method που επιστρέφεται σε κάθε σημείο εξόδου: σας επιτρέπει να μετρήσετε αναδρομικά ποιο ποσοστό περιεχομένου επεξεργάστηκε χωρίς ανθρώπινη παρέμβαση και, κατά συνέπεια, να προσαρμόσετε τα κατώφλια ανάλογα.
Fan-out / Fan-in
Το τελικό πρότυπο συνδυάζει τα προηγούμενα: διανομή εργασίας παράλληλα και στη συνέχεια συγχώνευση των αποτελεσμάτων σε ένα ενιαίο σημείο. Εδώ, ένα έγγραφο μεταφράζεται ταυτόχρονα σε τρεις γλώσσες, κάθε μετάφραση αναλύεται παράλληλα και όλα συγκλίνουν σε μια σύνοψη.
@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
@workflows.workflow.entrypoint
async def run(self, document: dict) -> dict:
# Fan-out: translate in parallel into 3 languages
translations = await asyncio.gather(
translate(document["text"], "en"),
translate(document["text"], "de"),
translate(document["text"], "es")
)
# Fan-out: analyze each translation in parallel
analyses = await asyncio.gather(
*[analyze_sentiment(trad["translated_text"]) for trad in translations]
)
# Fan-in: aggregate results
summary = await aggregate_analyses(list(analyses))
return summary
Τα δύο κύματα παραλληλισμού είναι διαδοχικά επειδή το δεύτερο εξαρτάται από τα αποτελέσματα του πρώτου. Σε αυστηρή ακολουθία, αυτό το workflow θα απαιτούσε επτά αλυσιδωτές κλήσεις· εδώ, κοστίζει μόνο τρία βήματα orchestration.
Συνοψίζοντας, διασπάστε τα σύνθετα workflows σε επαναχρησιμοποιήσιμα υπο-workflows, παραλληλοποιήστε όποτε οι δραστηριότητες είναι ανεξάρτητες, ενεργοποιήστε το return_exceptions=True όταν οι μερικές αστοχίες είναι ανεκτές, κρατήστε τη συνέχιση ως εφεδρεία για πολύ μεγάλες εργασίες επεξεργασίας και φροντίστε πάντα η διακλάδωσή σας να βασίζεται σε αποτελέσματα δραστηριοτήτων και όχι σε μη ντετερμινιστικές τιμές.
Βασικά σημεία
- Ένα workflow μπορεί να ενεργοποιήσει άλλα workflows μέσω μιας δραστηριότητας που καλεί το SDK
- Το πρότυπο συνέχισης επιτρέπει την επεξεργασία απεριόριστου αριθμού στοιχείων σε διαδοχικές παρτίδες
- Το
asyncio.gatherσας επιτρέπει να εκτελείτε δραστηριότητες παράλληλα για μείωση του συνολικού χρόνου - Η σύνθετη υπό όρους διακλάδωση υποστηρίζεται εφόσον εξαρτάται από αποτελέσματα δραστηριοτήτων
- Το πρότυπο fan-out / fan-in κατανέμει την εργασία και στη συνέχεια συγκεντρώνει τα αποτελέσματα