Scálú agus Ailtireachtaí Il-Ghníomhaire
Ar an leathanach seo
Scálú agus Ailtireachtaí Il-Ghníomhaire
Oibríonn do ghníomhaire do 10 n-úsáideoir. Conas a dhéanann tú é a rith do 10,000? Athraíonn na dúshláin: ní faoi theip ar threoracha atá sé a thuilleadh, ach faoi theorainneacha ráta an tsoláthraí, cuimhne freastalaí, agus do bhille míosúil. Sa cheacht deiridh seo, foghlaimeoidh tú conas do ghníomhairí a scálú, ailtireachtaí il-ghníomhaire ardfheidhmíochta a dhearadh, agus srianta táirgeachta a bhainistiú ar scála mór.
Ailtireacht Táirgeachta
An Cúlchóras Gníomhaire le FastAPI
Is é an chéad chinneadh struchtúrach ná timthriall beatha an ghníomhaire. Is amú ama é Agent a thógáil do gach iarratas agus scaipeann sé an chumraíocht; ligeann lifespan FastAPI duit iad a shamplú uair amháin ag am tosaithe agus iad a choinneáil i gclár innéacsaithe de réir cineáil. Léann an bealach an cineál a iarradh, diúltaíonn sé go glan mura bhfuil sé ann, agus sruthlaíonn sé an freagra: eisíonn run_streamed deiltí de réir mar a théann an ghiniúint ar aghaidh, rud a fhágann go bhfeictear téacs ar an scáileán láithreach in ionad an t-úsáideoir a fhágáil ag breathnú ar rothán lódála ar feadh ocht soicind.
from fastapi import FastAPI, Request, Depends, HTTPException
from fastapi.responses import StreamingResponse
from agents import Agent, Runner, function_tool
from contextlib import asynccontextmanager
import asyncio
# Pool of pre-configured agents
agents_registry = {}
@asynccontextmanager
async def lifespan(app: FastAPI):
# Initialize agents at startup
agents_registry["sales"] = Agent(
name="Sales Agent",
instructions="You assist customers with their purchases.",
model="gpt-5.6-terra",
tools=[search_product, calculate_price],
)
agents_registry["support"] = Agent(
name="Support Agent",
instructions="You provide technical support.",
model="gpt-5.6-terra",
tools=[check_ticket, create_ticket],
)
yield
agents_registry.clear()
app = FastAPI(lifespan=lifespan)
@app.post("/api/chat/{agent_type}")
async def chat(agent_type: str, request: Request):
agent = agents_registry.get(agent_type)
if not agent:
raise HTTPException(404, f"Agent '{agent_type}' not found")
body = await request.json()
async def stream():
result = Runner.run_streamed(agent, body["messages"])
async for event in result.stream_events():
if event.type == "raw_response_event":
if hasattr(event.data, "delta") and event.data.delta:
yield f"data: {event.data.delta}\n\n"
yield "data: [DONE]\n\n"
return StreamingResponse(stream(), media_type="text/event-stream")
Bainistiú Comhthreomhaireachta
Tá sé sábháilte oibiachtaí Agent a roinnt ar gach iarratas mar seo toisc go gcruthaíonn gach iarratas Runner neamhspleách: coinníonn an gníomhaire an chumraíocht, agus coinníonn an Runner an staid feidhmithe. Láimhseálann an SDK comhthreomhaireacht go dúchasach, agus ciallaíonn baisc teachtaireachtaí a phróiseáil corútáin a chruachadh in asyncio.gather. Is é an mionsonraí ríthábhachtach anseo ná return_exceptions=True: gan é, cealaíonn aon iarratas amháin a theipeann an baisc ar fad. Leis, faigheann tú earráidí mar luachanna, meaitseálann tú iad lena dteachtaireacht bhunaidh, agus próiseálann tú na nócha a naoi dtorthaí bailí.
import asyncio
from agents import Agent, Runner
agent = Agent(
name="Concurrent Agent",
instructions="You answer questions.",
model="gpt-5.6-terra",
)
async def process_parallel_requests(messages: list[str]):
"""Process multiple requests in parallel."""
tasks = [Runner.run(agent, msg) for msg in messages]
results = await asyncio.gather(*tasks, return_exceptions=True)
for msg, res in zip(messages, results):
if isinstance(res, Exception):
print(f"Error for '{msg}': {res}")
else:
print(f"'{msg}' -> {res.final_output[:50]}...")
return results
Patrúin Il-Ghníomhaire
Patrún an Mhaoirseora
Thar scála áirithe, éiríonn gníomhaire amháin le cúigear uirlis déag dodhéanta: méadaíonn a threoracha go míchuí, agus meathlaíonn a chuid roghanna. Roinneann patrún an mhaoirseora an obair i measc gníomhairí speisialaithe—taighde, anailís, scríbhneoireacht—agus tarmligíonn sé an ródaireacht do ghníomhaire tiomnaithe trí láimhseáil (handoff). Coinníonn gach speisialtóir treoracha gairide agus samhalt oiriúnach dá thasc: faigheann an anailís samhalt réasúnaíochta, ach rithann an maoirseoir, nach ndéanann ach glacadóir a roghnú, ar shamhalt tapa ós rud é go mbraitheann a chinneadh ar chúpla focal.
from agents import Agent, Runner, Handoff
search_agent = Agent(
name="Search",
instructions="You search for information on the web and in databases.",
tools=[WebSearchTool(), search_crm],
model="gpt-5.6-terra",
)
analysis_agent = Agent(
name="Analysis",
instructions="You analyze data and produce insights.",
model="gpt-5.6-sol",
)
writing_agent = Agent(
name="Writing",
instructions="You write professional reports in English.",
model="gpt-5.6-terra",
)
supervisor_agent = Agent(
name="Supervisor",
instructions="""You coordinate a team of specialized agents.
For each request:
1. Analyze what is needed
2. Delegate to specialized agents via handoff
3. The last agent produces the final response
Available agents:
- Search: to collect data
- Analysis: to analyze and interpret
- Writing: to produce the final deliverable""",
handoffs=[
Handoff(agent=search_agent, description="Collect data"),
Handoff(agent=analysis_agent, description="Analyze data"),
Handoff(agent=writing_agent, description="Write a report"),
],
model="gpt-5.6-terra", # Fast for routing
)
Patrún an Phíblíne
Nuair atá an seicheamh ar eolas roimh ré, is costais gan ghá é ligean do shamhalt an slabhra a chinneadh. Ceanglaíonn patrún an phíblíne céimeanna i do chód: bailigh, déan anailís, scríobh. Mar sin, tosaíonn anailís iomaíochta le dhá bhailiúchán a sheoladh le chéile—níl aon chúis leis an ngréasán agus an CRM fanacht le chéile—ansin seolann sé gach rud chuig an anailís, a bhfuil a aschur ag beathú na scríbhneoireachta. Faigheann tú sreabhadh oibre in-atáirgthe, inrianaithe céim ar chéim, a bhfuil a fhad iomlán cothrom leis an mbailiúchán is moille móide an dá chéim ina dhiaidh sin.
async def competitive_analysis_pipeline(company: str):
# Step 1: Parallel data collection
web_task = Runner.run(search_agent, f"Search for information about {company}")
crm_task = Runner.run(crm_agent, f"CRM data for {company}")
results = await asyncio.gather(web_task, crm_task)
data = f"""Web data: {results[0].final_output}
CRM data: {results[1].final_output}"""
# Step 2: Analysis
analysis = await Runner.run(analysis_agent, f"Analyze this data: {data}")
# Step 3: Report
report = await Runner.run(
writing_agent,
f"Write a competitive analysis report: {analysis.final_output}"
)
return report.final_output
Patrún Map-Reduce
Díríonn an tríú patrún ar fhadhb toirte seachas castacht. Ní oiriúnaíonn dhá mhíle barántúlacht ó chustaiméirí d’iarratas amháin agus ní féidir iad a anailísiú go seicheamhach in am réasúnta. Aicmíonn an céim MAP gach aiseolas go comhthreomhar le samhalt tapa agus aschur típithe; déanann an céim REDUCE na haicmiúcháin seo a thiomsú, atá i bhfad níos dlúithe ná na téacsanna bunaidh, agus tarmligíonn sé an tsintéis do shamhalt níos cumasaí. Titann an costas i gcomparáid leis an anailís iomlán, toisc go bpróiseáiltear an chuid is mó den toirt leis an tsamhalt is saoire.
async def analyze_feedbacks(feedbacks: list[str]):
# MAP: analyze each feedback in parallel
classifier_agent = Agent(
name="Classifier",
instructions="Classify the feedback: positive, negative, or neutral. Identify the main theme.",
model="gpt-5.6-terra",
output_type=FeedbackClassification,
)
tasks = [Runner.run(classifier_agent, fb) for fb in feedbacks]
classifications = await asyncio.gather(*tasks)
# REDUCE: synthesize results
summary_data = [
{"feedback": fb, "class": c.final_output.dict()}
for fb, c in zip(feedbacks, classifications)
]
synthesizer_agent = Agent(
name="Synthesizer",
instructions="Synthesize the feedback classifications into a report with statistics and insights.",
model="gpt-5.6-terra",
)
import json
report = await Runner.run(
synthesizer_agent,
f"Synthesize these {len(feedbacks)} classified feedbacks: {json.dumps(summary_data, ensure_ascii=False)}"
)
return report.final_output
Bainistiú Teorainneacha Ráta
Ní chríochnaíonn dhá mhíle glao comhuaineach níos tapúla: diúltaíonn an soláthraí duit agus cailltear an baisc. Teorannaíonn semaphore líon na bhfeidhmithe comhthreomhara, agus cuireann an bainisteoir thíos cúltarraingt easpónantúil leis atá teoranta do shéasca soicind nuair a tharlaíonn earráid teorann. Athshocraítear an t-áireamh earráidí chomh luath agus a éiríonn glao amháin, rud a sheachnaíonn pionós fadtéarmach ar an tseirbhís de bharr teagmhais thar sealach.
import asyncio
from agents import Runner
class RateLimitManager:
def __init__(self, max_concurrent: int = 10):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.error_count = 0
async def execute(self, agent, message, **kwargs):
async with self.semaphore:
try:
result = await Runner.run(agent, message, **kwargs)
self.error_count = 0
return result
except Exception as e:
if "rate_limit" in str(e).lower():
self.error_count += 1
wait_time = min(2 ** self.error_count, 60)
await asyncio.sleep(wait_time)
return await self.execute(agent, message, **kwargs)
raise
manager = RateLimitManager(max_concurrent=20)
Optamú Costais ar Scála
Ansin tá an bille ann. Laghdaíonn dhá ghiaráil é gan drochthionchar a imirt ar an tseirbhís. Is é an chéad cheann ná gan íoc as samhalt réasúnaíochta chun “cad iad do huaireanta” a fhreagairt: mapálann tábla cuardaigh leibhéal castachta don tsamhalt oiriúnach, ón gceann is eacnamaíche do cheisteanna simplí go dtí an ceann is cumasaí do chásanna criticiúla, le réamhshocrú do rud ar bith nach bhfuil aicmithe. Baineann an dara ceann leas as athrá—i dtacaíocht do chustaiméirí, filleann na ceisteanna céanna na céadta uair in aghaidh an lae, agus filleann taisce innéacsaithe ar hais teachtaireachta an freagra láithreach agus saor in aisce. Cuir an taisce seo in áirithe do cheisteanna nach mbraitheann a bhfreagra ar an úsáideoir ná ar an am: déanann polasaí fillte taisce go maith, ní dhéanann stádas ordaithe riamh.
# Model strategy by complexity
def choose_model(complexity: str) -> str:
models = {
"simple": "gpt-5.6-terra", # Simple questions: cheap
"medium": "gpt-5.6-terra", # Most cases
"complex": "gpt-5.6-terra", # Fast reasoning
"critical": "gpt-5.6-sol", # Critical cases: maximum quality
}
return models.get(complexity, "gpt-5.6-terra")
# Cache for frequent responses
from functools import lru_cache
import hashlib
response_cache = {}
async def execute_with_cache(agent, message: str):
key = hashlib.md5(message.encode()).hexdigest()
if key in response_cache:
return response_cache[key]
result = await Runner.run(agent, message)
response_cache[key] = result.final_output
return result.final_output
Príomhphointí
- Réamhchumraigh do ghníomhairí ag am tosaithe agus athúsáid iad thar iarratais
- Láimhseálann an SDK comhthreomhaireacht go dúchasach trí
asyncio.gather() - Comhordúnn patrún an mhaoirseora gníomhairí speisialaithe trí láimhseálacha (handoffs)
- Déanann patrún map-reduce próiseáil toirte móra comhthreomhar
- Bainistigh teorainneacha ráta le semaphore agus cúltarraingt easpónantúil
- Optamaigh costais le roghnú samhalt de réir castachta agus taisce
Tástáil do Chuid Eolais
Sula ndéanann tú scálú suas, seiceáil do chuid eolais ar ailtireacht gníomhairí.
1. Cad iad na bloic thógála den SDK Gníomhairí?
Freagra: Agent (an ról agus a threoracha), Runner (an lúb feidhmithe), Tool (na cumais), agus Guardrail (bailíochtuithe ionchuir/aschuir)—anatamaíocht aon ghníomhaire SDK.
2. Cad chuige a bhfuil Guardrails?
Freagra: Chun a bhailíochtú a théann isteach agus a fhágann an gníomhaire: scag iarratais lasmuigh den raon feidhme, rialaigh aschuir sula ngníomhaíonn siad—slándáil dearbhaithe san ailtireacht, ní rud a bhfuiltear ag súil leis ón leid.
3. Cad é láimhseáil (handoff)?
Freagra: Aistriú comhrá ó ghníomhaire amháin go gníomhaire eile, níos speisialaithe: comhordú il-ghníomhaire áit a ndéanann gach gníomhaire an rud is fearr atá ar eolas aige, agus an comhthéacs á leanúint.
4. Cén fáth a bhfuil rianú dosheachanta i dtáirgeadh?
Freagra: Toisc go gcinneann gníomhaire go dinimiciúil: gan rianta de chéimeanna, uirlisí glaodh, agus cinntí, tá dífhabhtú nó meastóireacht dodhéanta—scóráiltear na feidhmithe seo go beacht le grádú rianaithe.
5. Cathain ba chóir duit bogadh go hailtireacht il-ghníomhaire?
Freagra: Nuair a charnaíonn gníomhaire amháin an iomarca róil agus uirlisí: déanann tú speisialú (triage, saineolas, feidhmiú) agus comhordaíonn tú trí láimhseálacha—éiríonn gach gníomhaire simplí agus in-tástáil arís.
SDK, guardrails, handoffs, rianú: tá an creatlach críochnaithe—inis an scálú thuas duit conas é a chur in úsáid gan é a lagú.