Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Láimhseáil Earráidí

Ceacht 10 as 14 Nuashonraithe 2 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Tá Earráidí Dodhéanta
  2. Ná Folaigh Earráid Ón tSamhail Riamh
  3. Feidhmitheoir Nach Ligeadh Dada Dul Thar
  4. Déan idirdhealú idir Teipeanna Sealadacha agus Buana
  5. Is Féidir leis an API Mistral Teip Freisin
  6. Féach Cad atá Ag Tarlú i ndáiríre
  7. Príomhphointí

Tá Earráidí Dodhéanta

I dtimpeallacht táirgeachta, teipeann ar fheidhmeanna. Téann APIanna seachtracha síos, ní bhíonn IDanna ann, tá paraiméadair neamhbhailí, agus téann amanna feithimh in éag. Ní hé “an dteipfidh sé?” an cheist, ach “conas a láimhseálaimid teip go deas?” Ní córas táirgeachta é rianaire íocaíochta a thuairteálann toisc gur chlóscríobh úsáideoir T9999 in ionad T1001; is taispeántas é sin amháin.

Is dea-scéal é go bhfuil acmhainn agat nach mbíonn ag ailtireachtaí clasaiceacha: is féidir leis an tsamhail Mistral teachtaireachtaí earráide a sheolann tú ar ais a thuiscint agus a freagairt dá réir. I gcás ina gcaithfidh backend traidisiúnta teachtaireacht UI a chruthú do gach cód earráide, is féidir leat ligean don tsamhail an teip a aistriú go habairt chabhrach don úsáideoir. Ní gá duit ach an t-eolas a thabhairt di.

Ná Folaigh Earráid Ón tSamhail Riamh

Seo riail órga an cheachta seo. Seol earráid ar ais sa teachtaireacht tool díreach mar a dhéanfá le toradh gnáth: mar JSON struchtúrtha. Is é an frithghníomh contrártha—an eisceacht a ghabháil agus teaghrán folamh nó null a thabhairt ar ais—a chuireann ar an tsamhail creidiúint gur éirigh leis an bhfeidhm ach nach raibh aon rud le rá aici. Cruthaíonn sé seo na freagraí is mearbhaillaí is féidir.

def retrieve_payment_status(df, transaction_id: str) -> str:
    """Retrieves status with full error handling."""
    try:
        if transaction_id not in df["transaction_id"].values:
            return json.dumps({
                "error": "transaction_not_found",
                "message": f"Transaction {transaction_id} does not exist in the database."
            })

        status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
        return json.dumps({"status": status, "transaction_id": transaction_id})

    except Exception as e:
        return json.dumps({
            "error": "internal_error",
            "message": f"Error retrieving data: {str(e)}"
        })

Tá dhá réimse go leor: cód meaisine i error agus míniú inléite don duine i message. Ligeann an cód do do chóras monatóireachta líon na dtarluithe a chomhaireamh; ligeann an míniú don tsamhail freagra cabhrach a fhoirmiú. Féach cad a tharlaíonn le hidirbheart nach bhfuil ann.

# User requests a non-existent transaction
messages = [{"role": "user", "content": "Status of payment T9999?"}]

# Model calls retrieve_payment_status(transaction_id="T9999")
# Your function returns: {"error": "transaction_not_found", ...}

# Model formulates:
# → "I couldn't find a transaction with ID T9999.
#     Could you check the number and try again?"

Níor scríobh aon duine an abairt sin. Tagann sí ón gcód earráide, agus molann sí gníomh leasaitheach don úsáideoir fiú.

Feidhmitheoir Nach Ligeadh Dada Dul Thar

Ní leor feidhm a chosaint: tá modhanna teipthe féin ag an sraith a sheolann tool_calls, neamhspleách ar do lóic gnó. D’fhéadfadh an tsamhail ainm feidhme a mheabhrú nach bhfuil i do fhoclóir. D’fhéadfadh sí argóintí JSON míchumtha a tháirgeadh—cás annamh ach fíor le scéimeanna casta. D’fhéadfadh sí JSON bailí a sholáthar freisin nach bhfuil a chuid eochracha comhoiriúnach le síniú Python, rud a chruthódh TypeError le linn **function_params. Tuilleann gach ceann de na trí chás seo a chód earráide féin toisc go n-éilíonn gach ceann acu deisiú difriúil ar do thaobh.

def execute_tool_call(tool_call, available_functions):
    """Executes a tool_call with full error handling."""
    function_name = tool_call.function.name

    # Check if function exists
    if function_name not in available_functions:
        return {
            "role": "tool",
            "name": function_name,
            "content": json.dumps({
                "error": "function_not_found",
                "message": f"Function {function_name} is not available."
            }),
            "tool_call_id": tool_call.id
        }

    # Parse arguments
    try:
        function_params = json.loads(tool_call.function.arguments)
    except json.JSONDecodeError as e:
        return {
            "role": "tool",
            "name": function_name,
            "content": json.dumps({
                "error": "invalid_arguments",
                "message": f"Invalid JSON arguments: {str(e)}"
            }),
            "tool_call_id": tool_call.id
        }

    # Execute function
    try:
        result = available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }
    except TypeError as e:
        return {
            "role": "tool",
            "name": function_name,
            "content": json.dumps({
                "error": "invalid_params",
                "message": f"Incompatible parameters: {str(e)}"
            }),
            "tool_call_id": tool_call.id
        }
    except Exception as e:
        return {
            "role": "tool",
            "name": function_name,
            "content": json.dumps({
                "error": "execution_error",
                "message": f"Execution error: {str(e)}"
            }),
            "tool_call_id": tool_call.id
        }

Tabhair faoi deara go dtugann gach brainse, na brainse teipthe san áireamh, teachtaireacht tool iomlán ar ais lena tool_call_id féin. Tá sé seo riachtanach: diúltaíonn an API stair ina bhfuil tool_call gan freagra, agus chruthódh teip thostach earráid bailíochta ar an gcéad chas eile, i bhfad ón bhfíorchúis.

Déan idirdhealú idir Teipeanna Sealadacha agus Buana

Níl gach earráid mar an gcéanna. Beidh idirbheart in easnamh fós ar an dara hiarracht; is amú ama é athiarracht a dhéanamh. Áfach, réitíonn líonra a bhfuil am feithimh air nó seirbhís atá sáithithe go sealadach go minic leis féin. Don dara catagóir seo, tugann athiarracht le cúlú easpónantúil—a soicind, ansin dhá cheann, ansin ceathair—am don tseirbhís teacht chuici féin gan í a bhuailt le hiarratais. Tar éis duit na hiarrachtaí a ídiú, filleann tú ar an ngnáth-iompar: JSON earráide atá ceaptha don tsamhail.

import time

def execute_with_retry(func, params, max_retries=3, base_delay=1.0):
    """Executes a function with exponential retry."""
    for attempt in range(max_retries):
        try:
            result = func(**params)
            return result
        except ConnectionError as e:
            if attempt < max_retries - 1:
                delay = base_delay * (2 ** attempt)
                time.sleep(delay)
            else:
                return json.dumps({
                    "error": "service_unavailable",
                    "message": f"Service unavailable after {max_retries} attempts.",
                    "details": str(e)
                })

Is Féidir leis an API Mistral Teip Freisin

Baineann gach rud thuas le do fheidhmeanna. Is pointe teipthe ar leith é an glaoch chuig an API Mistral féin, agus láimhseáiltear ar leithligh é: anseo, níl aon tsamhail ann chun an fhadhb a mhíniú, ós í an tsamhail féin atá dodhéanta go díreach. De ghnáth, léiríonn HTTPValidationError earráid i do struchtúr teachtaireachta nó uirlisí, rud ar chóir duit a dheisiú sa chód; baineann eisceachtaí eile leis an líonra nó leis an tseirbhís agus láimhseáiltear iad leis an loic athiarrachta céanna leis an gceann thuas.

from mistralai.client import Mistral
from mistralai.client.errors import HTTPValidationError

def safe_chat_complete(client, model, messages, tools):
    """Mistral API call with error handling."""
    try:
        return client.chat.complete(
            model=model,
            messages=messages,
            tools=tools
        )
    except HTTPValidationError as e:
        print(f"Validation error: {e}")
        return None
    except Exception as e:
        print(f"API error: {e}")
        return None

Féach Cad atá Ag Tarlú i ndáiríre

Tá sé deacair córas glaonna feidhme a dhífhabhtú tar éis an fhíric mura bhfuil a fhios agat cén fheidhm a glaodh, le cad iad na hargóintí, agus cad a thug sé ar ais. Ní polais é logáil; is é an bealach a aimsíonn tú go mbogann cur síos doiléir an tsamhail chun dhá fheidhm a mheascadh, nó go spreagann ceann as gach cúig úsáideoir transaction_not_found go córasach. Logáil an glaoch roimh fheidhmiú, agus ansin an breithiúnas, ag déanamh idirdhealaithe idir leibhéal info agus leibhéal error ionas gur féidir le do chórais foláirimh scagadh go héifeachtach.

import logging

logger = logging.getLogger("function_calling")

def execute_and_log(tool_call, available_functions):
    """Executes and logs the result."""
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    logger.info(f"Call: {function_name}({function_params})")

    result = execute_tool_call(tool_call, available_functions)
    content = json.loads(result["content"])

    if "error" in content:
        logger.error(f"Failure {function_name}: {content['error']} - {content['message']}")
    else:
        logger.info(f"Success {function_name}: {content}")

    return result

Príomhphointí

  • Seol earráidí ar ais don tsamhail i gcónaí sa teachtaireacht tool—tá a fhios aici conas iad a léirmhíniú
  • Úsáid cóid earráide struchtúrtha (transaction_not_found, invalid_arguments, srl.)
  • Cuir athiarracht le cúlú i bhfeidhm le haghaidh earráidí sealadacha
  • Láimhseáil earráidí i do fheidhmeanna agus earráidí san API Mistral ar leithligh
  • Logáil gach glaoch agus gach earráid le haghaidh monatóireachta táirgeachta