I-ejenti yokuqapha imakethe nge-LangGraph kanye ne-Strands ku-AgentCore

Njengoba izinhlelo zokusebenza zobuhlakani bokwenziwa zishintsha zisuka kuma-chatbots alula ziye ezinhlelweni ezizimele ezizimele, izinhlangano zibhekana nezinselele ezintsha ekuhleleni ukugeleza komsebenzi okuyinkimbinkimbi kwama-agent amaningi akwazi ukubhekana nezimo zokukhiqiza zomhlaba wangempela. Izindlela zendabuko zomenzeli oyedwa zivame ukungaphumeleli lapho kubhekwana nezinqubo zebhizinisi eziyinkimbinkimbi ezidinga ubuchwepheshe obukhethekile, ukuthathwa kwezinqumo okuguquguqukayo, nezindlela eziqinile zokuthola amaphutha. Imboni yezinsizakalo zezezimali iyisibonelo sale nselelo. Amasistimu okuqapha izimakethe kufanele axhumanise ama-ejenti amaningi akhethekile ukuze ahlaziye amaphethini okuhweba, aphenye imisebenzi esolisayo, futhi akhiphe imibiko ephelele kuyilapho kugcinwa ukuthobelana okuqinile kanye nezindinganiso zokwethembeka.

Isixazululo sihlanganisa izinhlaka ezimbili: I-LangGraph ye-orchestration yezinga eliphezulu lokuhamba komsebenzi kanye ne-Strands yokucabanga kwe-ejenti ehlakaniphile. I-LangGraph ihamba phambili ekuphatheni amagrafu esifunda naqondisiwe ukuze kuhlanganiswe ama-agent amaningi. Ikunikeza ukulawula okuhlaziywe kahle kukho kokubili ukwenziwa kokugeleza komsebenzi kanye nesimo esingabiwa phakathi kwama-ejenti. Isendlalelo saso esimaphakathi sokuphikelela sisekela izici ezibalulekile zokukhiqiza, okuhlanganisa ukusebenzisana komuntu-in-the-loop kanye nokululama okusekelwe endaweni yokuhlola okuqinile kusukela ekuhlulekeni. Ngaleso sikhathi, i-Strands Agent isebenza njengenjini yokucabanga ngaphakathi kwama-node wokuhamba komsebenzi ngamunye. Ihlinzeka ngamakhono emodeli-ukungaziwa ahlanganiswe nabahlinzeki bemodeli yolimi olukhulu (LLM) ngenkathi igcina ukuhlanganiswa kwamathuluzi aguquguqukayo kanye nokubonakala okuphelele.

Ngokukhishwa kwe-Amazon Bedrock AgentCore ngonyaka odlule, ukukhiqiza isisombululo se-ejenti kungase kwenziwe lula ezimweni eziningi zokusetshenziswa. Inhlanganisela ihlinzeka ngesisekelo esiqinile sezinhlelo ze-AI ze-AI ezilungele ukukhiqiza ezingasingatha izimo eziyinkimbinkimbi zokusetshenziswa kuyilapho zisiza ukuletha ukwethembeka kwengqalasizinda nokuqashelwa okufunwa yizicelo zebhizinisi.

Kulokhu okuthunyelwe, sibonisa indlela yokuklama nokusebenzisa isistimu ye-AI enama-agent amaningi kusetshenziswa i-LangGraph ne-Strands kungqalasizinda ye-AWS. Ufunda indlela yokusebenzisa i-orchestration yokugeleza komsebenzi eshayelwa uhulumeni ngohlelo lokuhlola lwe-LangGraph, ukuhlanganisa ama-Strands abenzeli bemisebenzi yokucabanga ekhethekile, futhi usebenzise i-AgentCore ukuze ukhiphe ukukhiqizwa okungaka. Isixazululo esiphelele siyatholakala ku-GitHub.

Imicu: Ukucabanga komenzeli ohlakaniphile

I-Strands Agent isebenza ku-architecture yemodeli-agnostic evumelana nengqalasizinda yakho ekhona ngaphandle kokubeka imingcele yezakhiwo. I-ejenti isebenzisa iluphu yokucabanga ye-ejenti ehlaziya ngokuqhubekayo okuphumayo kwamathuluzi futhi yenza izinqumo ngokusekelwe emiphumeleni emaphakathi, ukuze ukwazi ukwakha ukugeleza komsebenzi wokuhlaziya okuyizinyathelo eziningi. Uhlaka luhlanganisa iseshini ebanzi nokuphathwa kwezwe kanye nabaphathi bezingxoxo eziningi ukuze kuvinjwe iwindi lomongo wakho ukuthi lingaphumi.

Nge-Strands, ungamisa ukusebenzisana kwamathuluzi angaphandle ngokuchaza izikimu zamathuluzi namaphethini okufinyelela. Kumenzeli wethu wokugada, sihlukanisa ukutholwa kwedatha ekubuyiseni ukuze sigweme imibono engekho kanye nokuqinisa isisombululo ngokumelene nokuhlaselwa komjovo. Sisebenzisa amathuluzi afana get_report_list futhi get_report_schema ukuthola imibiko kanye run_report ukwakha umbuzo we-SQL ngamapharamitha aqinisekisiwe futhi uyiqhube.

Sakha a security_monitor umenzeli onamathuluzi alandelayo kanye nomyalo wesistimu:

from strands import Agent, tool
from strands.models.bedrock import BedrockModel

model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-6",
    region_name="us-east-1",
    max_tokens=16000,
    additional_request_fields={
        "thinking": {"type": "adaptive", "budget_tokens": 8000},
    },
    cache_prompt="default",
)

@tool
def get_report_list(agent_name: str) -> str:
    """Load the list of available reports for a specific agent.

    Args:
        agent_name: Name of the agent (e.g. 'security_monitor').

    Returns:
        str: JSON array of report objects with name and description.
    """
    reports_data = load_agent_reports(agent_name)
    return json.dumps(reports_data["reports"], indent=2)

@tool
def get_report_schema(report_name: str, query_intent: str) -> str:
    """Load column definitions for a report so you can build queries.

    Args:
        report_name: Name of the report (e.g. 'TradeActivity').
        query_intent: Description of what data to extract.

    Returns:
        str: JSON object with parameters and column definitions.
    """
    return json.dumps(load_json_report_definition(report_name), indent=2)

@tool
def run_report(
    report_name: str,
    filters: Dict[str, Any],
    limit: Optional[int] = None,
) -> Dict[str, Any]:
    """Run a predefined report. The tool validates every filter against the
    report's schema and builds a parameterised SQL query. The LLM never writes
    raw SQL, so filter values cannot be injected into the query.

    Args:
        report_name: A report from `get_report_list` (e.g. 'TradeActivity').
        filters: Equality filters keyed by column name, e.g.
            {"symbol": "AAPL", "date": "2024-03-15"}.
        limit: Optional row cap (1..10000).

    Returns:
        dict: {'success': bool, 'data': str (CSV), 'error': str or None}
    """
    schema = load_json_report_definition(report_name)
    allowed_columns = {c["name"] for c in schema["columns"]}

    # Reject any filter field that is not in the report's allowed list of columns.
    unknown = set(filters) - allowed_columns
    if unknown:
        raise ValueError(
            f"Unknown filter field(s) {sorted(unknown)} for {report_name}. "
            f"Allowed: {sorted(allowed_columns)}"
        )

    # Build SQL with named bind parameters.
    where = " AND ".join(f"{field} = :{field}" for field in filters)
    sql = f"SELECT * FROM {schema['reportName']}"
    if where:
        sql += f" WHERE {where}"
    if limit is not None:
        if not isinstance(limit, int) or not 1 <= limit <= 10_000:
            raise ValueError("limit must be an integer in [1, 10000]")
        sql += f" LIMIT {limit}"

    return query_market_data(report_name=report_name, sql=sql, bind=filters)

security_monitor = Agent(
    model=model,
    system_prompt=SECURITY_MONITOR_PROMPT,
    tools=[get_report_list, get_report_schema, run_report],
    name="security_monitor",
)

I-LangGraph: I-Macro workflow orchestration

I-LangGraph inikeza i-orchestration yebanga lokukhiqiza yezinhlelo zama-ejenti amaningi ngokusebenzisa amakhono amathathu ayinhloko ayenza ifaneleke kahle ukuhamba komsebenzi kwe-AI okuyinkimbinkimbi.

Imishini yezwe esekwe kugrafu: I-ejenti yamamodeli e-LangGraph igeleza njengamagrafu aqondisiwe lapho amanodi amelela khona imisebenzi equkethe ukunengqondo komenzeli, futhi imiphetho inquma ukugeleza kokusayinda. Le ndlela yokumemezela iguqula ukucabanga okunezinyathelo eziningi kube ikhodi efundekayo, egcinekayo. Amagrafu asekela i-branching enemibandela, ukusebenza okufanayo, nomzila oguqukayo. Lawa makhono abalulekile kuzimo zomhlaba wangempela lapho ukugeleza komsebenzi kuzivumelanisa khona ngokusekelwe emiphumeleni emaphakathi.

Ukuphathwa kombuso okuqhubekayo: Uhlelo lokuhlola lohlaka luthwebula ngokuzenzakalelayo isimo sokugeleza komsebenzi esiphelele ngemva kokusebenza kwenodi ngayinye. Ngalawa maphoyinti okuhlola, ungalulama ngokushelela ekuhlulekeni futhi usekele ukusebenzisana komuntu-in-the-loop. Uma abahlaziyi bedinga ukubuyekeza imiphumela emaphakathi noma kwenzeka amaphutha, isistimu ibuyisela endaweni yokuhlola ngqo. Bese iqala futhi ngaphandle kokulahlekelwa umsebenzi wangaphambilini. Lesi sakhiwo esihle sisekela amaphethini avame ukusetshenziswa njengezingxoxo ezishintshashintshayo, ukulungiswa okuphindaphindiwe, nophenyo oluthatha isikhathi eside oluthatha amahora noma izinsuku.

Ukuthembeka kokukhiqiza: I-LangGraph ihlanganisa amasu akhelwe ngaphakathi okuzama kabusha ane-exponential backoff yokuphatha i-throttling noma okunye ukwehluleka okungenzeka kusistimu yakho. Iphinde inikeze ukubonwa okuphelele nge-OpenTelemetry ukuze kuhlanganiswe okuqondile nezinhlelo zokusebenza eziningi zokubonakala.

Ake sakhe isendlalelo se-orchestration esiqondisa imibuzo phakathi kwama-ejenti ethu angochwepheshe be-Strands. Ikhodi elandelayo ichaza igrafu yethu yokugeleza komsebenzi: isimo esabiwe, i-orchestrator ekhetha ukuthi yimaphi ama-ejenti angochwepheshe azowacela, umzila onemibandela phakathi kwawo, kanye nokuphikelela okusekelwe endaweni yokuhlola ukuze kutholakale futhi kubuyekezwe umuntu-on-the-loop.

from typing import TypedDict, Optional, List, Dict, Any
from langgraph.graph import END, StateGraph
from langgraph_checkpoint_aws import AgentCoreMemorySaver

class AgentState(TypedDict):
    query_text: str
    session_id: Optional[str]
    agent_task_map: Optional[Dict[str, str]]
    required_agents: Optional[List[str]]
    current_agent_index: Optional[int]
    # Each specialist writes its insights here
    security_monitor_insights: Optional[Dict[str, Any]]
    broker_monitor_insights: Optional[Dict[str, Any]]
    risk_monitor_insights: Optional[Dict[str, Any]]
    intel_analyst_insights: Optional[Dict[str, Any]]
    synthesizer_insights: Optional[str]

SPECIALIST_NODES = {
    "security_monitor": security_monitor_node,
    "broker_monitor": broker_monitor_node,
    "risk_monitor": risk_monitor_node,
    "intel_analyst": intel_analyst_node,
}

def route_analysts(state: AgentState) -> str:
    """Dynamic routing --- walk the required_agents list by index."""
    required = state.get("required_agents", [])
    index = state.get("current_agent_index", 0)
    if not required:
        return END
    if index < len(required):
        return required[index]
    return "synthesizer"

# Build the graph
workflow = StateGraph(AgentState)
workflow.add_node("orchestrator", orchestrator_node)
for name, node_fn in SPECIALIST_NODES.items():
    workflow.add_node(name, node_fn)
workflow.add_node("synthesizer", synthesizer_node)
workflow.set_entry_point("orchestrator")

# Conditional edges --- the orchestrator and every specialist route through route_analysts, which can hand off to any specialist or the synthesizer.
ALL_TARGETS = {name: name for name in SPECIALIST_NODES} | {
    "synthesizer": "synthesizer",
    END: END,
}
workflow.add_conditional_edges("orchestrator", route_analysts, ALL_TARGETS)
for name in SPECIALIST_NODES:
    workflow.add_conditional_edges(name, route_analysts, ALL_TARGETS)
workflow.add_edge("synthesizer", END)

# AgentCoreMemorySaver checkpoints the state after every node
checkpointer = AgentCoreMemorySaver(MEMORY_ID, region_name=REGION)
graph = workflow.compile(checkpointer=checkpointer)

Kungani LangGraph kanye Strands ndawonye

Amacala amaningi okusetshenziswa kwebhizinisi kufanele asekelwe ekugelezeni okuqinile, okuchazwe ngaphambilini. Ukuthembela ngokuphelele kumvelo enganqunyelwe ye-LLM ukuze isebenzise izinyathelo ezifanele kuyingozi. Kodwa-ke, izinyathelo ezithile ngaphakathi kwalokho kugeleza komsebenzi zidinga ukucabanga okushesha nokuhlakanipha kwe-LLM.

Inhlanganisela ye-LangGraph ne-Strands ivala leli gebe. Ungayisebenzisa ukuze wakhe amasistimu lapho izindlu zokucula ze-deterministic zenziwe zasendaweni, ezihlakaniphile eziguqukayo.

Nansi indlela lokhu kubhanqa kwezakhiwo kuzixazulula kanjani izinselelo eziyinkimbinkimbi zokuhamba komsebenzi:

“Node” level intelligence: I-LangGraph ichaza i-orchestration yezinga eliphezulu yokugeleza komsebenzi. Ama-Strands agents abekwa ezindaweni ezithile, lapho ukugeleza komsebenzi okuyinkimbinkimbi kungase kudinge ukuhlaziywa kwe-LLM noma ukungaqondakali kokuzulazula. Basebenzisa ukucabanga okuzimele kanye nokusetshenziswa kwamathuluzi kuphela lapho lokho kuvumelana nezimo kudingekile khona ngokuqinile.

Ukuhlukaniswa kokuqukethwe ngama-nodal agents: Ama-Monolithic agents alahlekelwa kalula ukulandela imiyalelo yawo. Ngokubeka ama-Strands agents ngaphakathi kwamanodi ahlukene e-LangGraph, uhlukanisa inkumbulo. Umenzeli ngamunye uphatha eyakhe umongo ogxile kakhulu kanye nomlando wamathuluzi, kuyilapho i-LangGraph igcina iseshini ehlelekile, ehlanganisa yonke indawo isho ukuthi lawa ma-ejenti ahlukene angabuyekeza futhi abhekisele ngokuzimela.

I-orchestration eshaja kakhulu: Emgogodleni wayo, i-LangGraph iyithuluzi lezinga eliphansi lomzila ne-orchestration. Ngokushumeka Imicu, uxhuma ngokushesha uhlaka lwe-ejenti yebhizinisi oluphelele kugrafu yakho. Uthola umzila oqinile we-LangGraph eceleni kokuhlanganiswa komdabu kwe-Strands'Model Context Protocol (MCP), izilawuli zokuqondisa, imigqa yokuphepha, nokuhlola.

Ngokuqondile, uchwepheshe ngamunye uyinodi ye-LangGraph. I-node ivula i-ejenti entsha ye-Strands ngesistimu yayo esheshayo, amathuluzi, nomongo ohlukile. Iqhuba umsebenzi i-orchestrator eyabelwe futhi ibuyisela isibuyekezo sesimo. I-LangGraph ihlanganisa leso sibuyekezo esiyingxenye endaweni okwabelwana ngayo amanye amanodi afundwa kuso. Nansi indawo yokuqapha ukuphepha:

async def security_monitor_node(state: AgentState) -> AgentState:
    """
    Single-day activity analyst agent that assesses price, volume and tick-level trades
    """
    agent = Agent(
        name="security_monitor",
        model=analyst_model,
        system_prompt=SECURITY_MONITOR_PROMPT,
        tools=[get_report_list, get_report_schema, run_report],
        callback_handler=None,
    )

    # Pull this node's task from the shared state the orchestrator populated.
    task = state.get("agent_task_map", {}).get("security_monitor", state["query_text"])

    # Strands runs its own reasoning + tool loop; collect the agent's final text.
    chunks = []
    async for event in agent.stream_async(task):
        if "data" in event:
            chunks.append(event["data"])
    result = "".join(chunks)

    # Return shared state updates
    return {
        "security_monitor_insights": {"task": task, "business_insights": result},
        "current_agent_index": state.get("current_agent_index", 0) + 1,
    }

Ingqalasizinda ye-AWS kanye nokusetshenziswa ne-AgentCore

I-Amazon Bedrock AgentCore ihlinzeka ngensizakalo ephethwe ngokugcwele yokuphakela kanye nama-ejenti asebenzayo ngezinga, ukunciphisa ukuphathwa kwengqalasizinda ngenkathi iletha amakhono ebanga lokukhiqiza.

Ukuthunyelwa kwesikhathi sokusebenza: Isikhathi sokusebenza se-AgentCore, ikhono le-Amazon Bedrock AgentCore, siguqula ikhodi ye-ejenti yendawo ibe ukuthunyelwa komdabu kwamafu ngokucushwa okuncane. Isevisi inguhlaka olungenalwazi futhi isebenza ne-LangGraph ne-Strands ngaphandle kwebhokisi. Ihlinzeka ngengqalasizinda eyakhelwe inhloso yomthwalo womsebenzi wama-ejenti aguqukayo, okuhlanganisa izikhathi zokusebenza ezinwetshiwe zophenyo oluthatha isikhathi eside, ukwenziwa ukubambezeleka okuphansi kokugeleza komsebenzi okusebenzisanayo, kanye nokukala okuzenzakalelayo okusekelwe esidingekayo.

Sebenzisa i-orchestrator yakho ye-LangGraph nama-Strands agents usebenzisa i-AgentCore Python SDK, amandla e-Amazon Bedrock AgentCore, kanye nekhithi yamathuluzi yokuqala. Isikhathi sokusebenza siphatha ukuqukatha, ukunethiwekha, nokubala ukunikezwa ngokuzenzakalelayo. I-AgentCore iphatha ukuphakamisa okusindayo okungahlukanisiwe kwe-orchestration yesiqukathi, ukukala, nokuphathwa kweseshini.

# api.py --- AgentCore runtime entry point
from bedrock_agentcore.runtime import BedrockAgentCoreApp
from src.agents import Workflow

app = BedrockAgentCoreApp()
workflow = Workflow()

@app.entrypoint
async def market_surveillance_workflow(payload):
    """Invoked by AgentCore for each request. Yields streaming chunks."""
    prompt = payload.get("prompt")
    session_id = payload.get("session_id", "default-session")
    actor_id = payload.get("actor_id", "default-actor")
    async for chunk in workflow.stream_query(
        session_id=session_id, prompt=prompt, actor_id=actor_id
    ):
        yield chunk

if __name__ == "__main__":
    app.run()

# Deploy with the AgentCore starter toolkit
from bedrock_agentcore_starter_toolkit import Runtime

runtime = Runtime()
runtime.configure(
    entrypoint="api.py",
    auto_create_execution_role=True,
    auto_create_ecr=True,
    requirements_file="requirements.txt",
    region="us-east-1",
    agent_name="market_surveillance_workflow",
)
result = runtime.launch()
print(f"Agent ARN: {result.agent_arn}")

# Invoke the deployed agent
import boto3, json

client = boto3.client("bedrock-agentcore", region_name="us-east-1")
response = client.invoke_agent_runtime(
    agentRuntimeArn=result.agent_arn,
    qualifier="DEFAULT",
    payload=json.dumps({
        "prompt": "What caused the AAPL price spike at 11:00 AM on March 15, 2024?",
        "session_id": "session-001",
        "actor_id": "analyst-jane",
    }),
)

# AgentCore returns a server-sent-events stream. Parse it:
for raw in response["response"].iter_lines():
    if not raw:
        continue
    line = raw.decode("utf-8") if isinstance(raw, bytes) else raw
    if not line.startswith("data: "):
        continue
    try:
        chunk = json.loads(line[6:])
        if isinstance(chunk, str) and chunk.startswith("data: "):
            chunk = json.loads(chunk[6:])
    except json.JSONDecodeError:
        continue  # malformed chunk --- skip, don't crash
    if isinstance(chunk, dict) and chunk.get("type") == "text":
        print(chunk["content"], end="")

Ukuhlanganiswa kwenkumbulo: I-LangGraph ihlanganisa nenkumbulo ye-AgentCore, ikhono le-Amazon Bedrock AgentCore, ngokusebenzisa langgraph-checkpoint-aws iphakheji enemigqa embalwa yekhodi, ehlinzeka kokubili ukuphikelela kwephoyinti lokuhlola lesikhathi esifushane kanye nokubuyiswa kwenkumbulo yesikhathi eside okuhlakaniphile.

I AgentCoreMemorySaver ikilasi, elisetshenziswe kulesi sibonelo, liphatha izinto zokuhlola eziqukethe imilayezo yomsebenzisi, izimpendulo ze-AI, isimo sokusetshenziswa kwegrafu, kanye nemethadatha. Ngemva kokuqedwa kwenodi ngayinye, i-LangGraph igcina ngokuzenzakalelayo izindawo zokuhlola kumemori ye-AgentCore. Uthola izingxoxo ezimnandi kanye nokululama kokugeleza komsebenzi ngaphandle kokuphatha amathebula e-Amazon DynamoDB noma ukusebenzisa i-logic ye-serialization yangokwezifiso.

I AgentCoreMemoryStore ikilasi lihlinzeka ngamakhono enkumbulo ahlakaniphile lapho i-AgentCore ikhipha khona ngokuzenzakalelayo imininingwane, izifinyezo, nokuthandwayo komsebenzisi ezingxoxweni. Ama-ejenti angasesha ngalezi zinkumbulo ekusebenzisaneni okuzayo, ukuze ukwazi ukuletha ukuzizwisa komuntu siqu okuba ngcono ngokuhamba kwesikhathi. Lokhu kubhekana nenselelo eyisisekelo yokungabi nasimo kwe-ejenti: ukusebenzisana ngakunye kwakhela phezu kolwazi lwangaphambilini kunokuthi kuqale kabusha.

import boto3, time

REGION = "us-east-1"
control_client = boto3.client("bedrock-agentcore-control", region_name=REGION)

response = control_client.create_memory(
    name="MarketSurveillanceMemory",
    description="Memory for market surveillance multi-agent workflow.",
    eventExpiryDuration=90,  # days
)
MEMORY_ID = response["memory"]["id"]
print(f"Memory ID: {MEMORY_ID}")

# Wait for ACTIVE, with a 10-minute deadline. Creation normally takes 1-3 min.
deadline = time.time() + 600
while True:
    status = control_client.get_memory(memoryId=MEMORY_ID)["memory"]["status"]
    if status == "ACTIVE":
        break
    if status == "FAILED" or time.time() >= deadline:
        raise RuntimeError(f"Memory {MEMORY_ID} is {status!r} (expected ACTIVE)")
    time.sleep(10)

Ekwakhiweni kwegrafu:

checkpointer = AgentCoreMemorySaver(MEMORY_ID, region_name=REGION)
graph = workflow.compile(checkpointer=checkpointer)

Ekunxuseni, dlula thread_id futhi actor_id kumenzeli. Lezi izihlonzi ezihlukile zomsebenzisi neseshini:

config = {
    "configurable": {
        "thread_id": "surveillance-session-001",
        "actor_id": "analyst-jane",
    }
}

response = await graph.ainvoke(
    {"query_text": "Which brokers were most active?"},
    config=config,
)

Ukubonakala nokusebenza: I-AgentCore ihlanganisa ukubonwa okwakhelwe ngaphakathi ngokuhlanganiswa ne-Amazon CloudWatch ne-AWS X-Ray, ukuthwebula ukulandelana kokwenziwa komenzeli, ukunxusa kwamathuluzi, namamethrikhi okusebenza. Isevisi inikeza amadeshibhodi okuqapha ukuziphatha kwe-ejenti, ukuhlonza izingqinamba, nokuthuthukisa izindleko. Ihlanganiswe nemicimbi ye-OpenTelemetry ye-LangGraph, uthola ukubonakala okuphelele kusukela ku-orchestration yokuhambahamba komsebenzi okusezingeni eliphezulu kwehle kuye kumakholi we-LLM angawodwana nezinyathelo zokucabanga.

Isiphetho

Kulokhu okuthunyelwe, sibonise ukuthi siwakha kanjani amasistimu e-AI alungele ukukhiqiza ama-agent amaningi ngokuhlanganisa i-LangGraph's robust flowflow orchestration namandla okucabanga e-Strands' ejenti ehlakaniphile, asetshenziswe engqalasizinda ye-AWS.

Isakhiwo esiyingxubevange esisihlolile sibonisa indlela i-LangGraph ephumelela ngayo ku-orchestration yeleveli enkulu (ukuphatha ukusebenzelana kwe-ejenti, ukuphikelela kombuso, nokutholwa kokuhamba komsebenzi) kuyilapho ama-Strands ehlinzeka ngenjini yokucabanga enemininingwane ngaphakathi kwamanodi angawodwana. Ngalokhu kuhlukaniswa kokukhathazeka, ungakha amasistimu ayinkimbinkimbi aphatha izinqubo zebhizinisi eziyinkimbinkimbi kuyilapho ugcina ukwethembeka kokukhiqiza ngokuthola kabusha okusekelwe endaweni yokuhlola kanye nokubonakala okuphelele.

Cabangela ukunweba lesi sakhiwo kwezinye izimo ze-orchestration eziyinkimbinkimbi njengamapayipi okucubungula amadokhumenti, isevisi yekhasimende ezenzakalelayo, noma amasistimu okuqapha ukuthobela. Imvelo yemodeli ye-agnostic ye-Strands ehlanganiswe nokuphathwa kwezwe kwe-LangGraph yenza le phethini ibaluleke kakhulu ezinhlelweni zebhizinisi ezidinga kokubili ukuguquguquka nokwethembeka.

Ukuze ungene ujule emininingwaneni yokusetshenziswa kobuchwepheshe futhi uzakhele umenzeli wokuhlaziya imakethe, bona inqolobane ye-GitHub.

Mayelana nababhali