Wie wenn Sie Ihrem Freund sagen, dass Sie eine Fahrt zum Flughafen um 6 Uhr brauchen, und sie beginnen, Ihnen stattdessen über ihre Lieblings-Flughafen-Restaurants zu erzählen? Was ist Funktion Calling? Funktionelle Anrufe sind, wenn eine KI versteht, dass sie ein externes Werkzeug oder eine Dienstleistung verwenden muss, um eine Aufgabe zu erledigen.Es ist wie eine intelligente Assistentin zu haben, die nicht nur versteht, was Sie wollen, sondern weiß, wann sie ihr Telefon herausziehen müssen, um das Wetter zu überprüfen, nach Richtungen zu suchen oder ein Taxi zu rufen. In technischer Hinsicht ermöglicht Funktionsaufruf, dass KI-Modelle erkennen können, wann bestimmte Funktionen verwendet werden sollen, welche Parameter weitergegeben werden sollen und wie die Daten ordnungsgemäß formatiert werden können - alles von natürlichen Sprachanweisungen aus. The Dark Ages: Before Function Calling – Die dunklen Zeiten: Bevor die Funktion ruft Bevor die Funktion angerufen wurde, waren die Dinge ... verwirrt. Wenn Sie eine KI mit externen Tools verwenden wollten, hatten Sie zwei ebenso frustrierende Optionen: 
 
 
 
 
 Train the AI to generate exact API calls (which often went wrong) 
 
 Write complex code to parse AI responses and extract parameters Es ist, als würde man versuchen, jemandem einen Tanz zu lehren, indem man die Bewegungen in Worten beschreibt, anstatt sie zu zeigen.Sie würden etwas sagen, "Ich brauche Wetterdaten für New York" und die KI würde mit Text über das Wetter antworten, nicht die tatsächlichen Daten, die Sie brauchten. Ich erinnere mich, einen Chatbot zu bauen, der Restaurants Reservierungen buchen sollte. Ohne Funktion Calling würde es den Benutzern gerne sagen: "Ich habe Ihren Tisch gebucht!" ohne sich tatsächlich mit einem Buchungssystem zu verbinden. Warum Funktionen Dinge nennen Funktioneller Anruf bridgt die Lücke zwischen menschlicher Sprache und Computersystemen. 
 
 
 
 
 
 It's more reliable - the AI structures data exactly as functions need it 
 
 It's more capable - an AI can access real-time data, control devices, or run calculations 
 
 It's more natural - users can make requests in plain language Denken Sie an Funktionsaufrufe als den Zugang einer KI zu einer Werkzeugbox.Vorher konnte es nur über Hammer sprechen.Jetzt kann es einen holen und tatsächlich einen Nagel treiben. Ein einfacher Weg, darüber nachzudenken Stellen Sie sich vor, Sie sind in einem Café.Wenn Sie sagen, "Ich möchte einen mittleren Latte mit Hafermilch", sind Sie im Wesentlichen "Funktion Calling" der Barista. Die Funktion könnte aussehen wie: make_coffee(size="medium", drink_type="latte", milk="oat")
 Der Barista weiß: 
 
 
 
 
 
 
 Identify the function needed (make a drink) 
 
 Extract the parameters (size, type, milk choice) 
 
 Execute the function (make the coffee) 
 
 Return the result (your drink) Ohne Funktion Calling, würden Sie eine Antwort wie: "Ein mittlerer Latte mit Hafermilch klingt köstlich!" aber kein tatsächlicher Kaffee. Hope you get the idea ! Die Kernmechanik hinter dem Funktionsaufruf Im Mittelpunkt steht das Funktionsaufrufen aufgrund mehrerer technischer Innovationen, die zusammenarbeiten: 
 
 
 
 
 
 
 
 : When you define functions for an AI model to use, you provide a clear schema that includes the function name, description, and parameter specifications with their types and requirements. This JSON schema helps the model understand not just what the function does, but exactly what information it needs to execute properly. Structured Function Definitions 
 
 : The AI model analyzes user input to determine when a function should be called. Modern models like GPT-4 can recognize when a user's request could be satisfied by calling an external function, even when the user doesn't explicitly ask for it. Intent Recognition 
 
 : The model identifies and extracts relevant parameters from natural language, converting them into the structured format required by the function. For example, when someone asks about Microsoft stock, the model knows to extract "MSFT" as the ticker parameter. Parameter Extraction 
 
 : After a function executes, the model receives the result and incorporates it into a natural language response, creating a seamless experience for the user. Response Formatting 
 
 : The model maintains context throughout the conversation, allowing it to use previous function calls and responses to inform new function calls. Context Awareness ️ Scaffolding Code für Funktion Calling Hier ist eine Vorlage, mit der Sie mit dem Funktionsaufruf mit der OpenAI API beginnen können: from openai import OpenAI
import json

# Initialize the client
client = OpenAI()

# Define your functions
functions = [
    {
        "type": "function",
        "function": {
            "name": "your_function_name",
            "description": "Description of what this function does",
            "parameters": {
                "type": "object",
                "properties": {
                    "param1": {
                        "type": "string",
                        "description": "Description of parameter 1"
                    },
                    "param2": {
                        "type": "integer",
                        "description": "Description of parameter 2"
                    }
                },
                "required": ["param1"]
            }
        }
    }
]

# Your actual implementation of the function
def your_function_name(param1, param2=None):
    # Your code here
    result = f"Did something with {param1}"
    if param2:
        result += f" and {param2}"
    return result

# Process messages and handle function calls
def process_with_function_calling(messages):
    # Get response from the model
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=functions,
        tool_choice="auto"
    )
    
    response_message = response.choices[0].message
    
    # Check if the model wants to call a function
    if response_message.tool_calls:
        # Append the model's response to messages
        messages.append(response_message)
        
        # Process each function call
        for tool_call in response_message.tool_calls:
            function_name = tool_call.function.name
            function_args = json.loads(tool_call.function.arguments)
            
            # Call the function
            if function_name == "your_function_name":
                function_response = your_function_name(
                    function_args.get("param1"),
                    function_args.get("param2")
                )
                
                # Append the function response to messages
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "name": function_name,
                    "content": function_response
                })
        
        # Get a new response from the model
        second_response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages
        )
        
        return second_response.choices[0].message.content
    
    return response_message.content

# Example usage
messages = [{"role": "user", "content": "Your user query here"}]
result = process_with_function_calling(messages)
print(result)
 ☀️ Ein Arbeitsbeispiel: Wetterchecker Lassen Sie uns dies mit einer einfachen Wettercheckfunktion mit Azure OpenAI in die Praxis umsetzen: 

from openai import AzureOpenAI
import json
import requests


# Initialize the Azure OpenAI client
client = AzureOpenAI(
    api_key="your key",  
    api_version="2024-10-21",  # Make sure to use a version that supports function calling
    azure_endpoint="your endpoint"
)


# Define the weather function
weather_functions = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City name, e.g., 'San Francisco'"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

# Implement the weather function
def get_weather(location, unit="celsius"):
    # In a real app, you'd call a weather API here
    # This is a mock implementation
    weather_data = {
        "San Francisco": {"temp": 18, "condition": "Foggy"},
        "New York": {"temp": 22, "condition": "Partly Cloudy"},
        "London": {"temp": 15, "condition": "Rainy"},
        "Tokyo": {"temp": 24, "condition": "Sunny"}
    }
    
    # Get data for the location or return a default
    data = weather_data.get(location, {"temp": 20, "condition": "Unknown"})
    
    # Convert temperature if needed
    temp = data["temp"]
    if unit == "fahrenheit":
        temp = (temp * 9/5) + 32
    
    return f"It's currently {data['condition']} and {temp}°{'F' if unit == 'fahrenheit' else 'C'} in {location}."

# Process messages with weather function
def check_weather(user_query):
    messages = [{"role": "user", "content": user_query}]
    
    # Get response from the model
    response = client.chat.completions.create(
        model="gpt-4o-mini",  # The name you gave your deployment
        messages=[{"role": "user", "content": user_query}],
        tools=weather_functions,
        tool_choice="auto"
    )
    
    response_message = response.choices[0].message
    
    # Check if the model wants to call the weather function
    if response_message.tool_calls:
        # Append the model's response to messages
        messages.append(response_message)
        
        # Process each function call
        for tool_call in response_message.tool_calls:
            function_name = tool_call.function.name
            function_args = json.loads(tool_call.function.arguments)
            
            # Call the weather function
            if function_name == "get_weather":
                function_response = get_weather(
                    function_args.get("location"),
                    function_args.get("unit", "celsius")
                )
                
                # Append the function response to messages
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "name": function_name,
                    "content": function_response
                })
        
        # Get a new response from the model
        second_response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages
        )
        
        return second_response.choices[0].message.content
    
    return response_message.content

# Try it out
result = check_weather("What's the weather like in Tokyo right now?")
print(result)
 When you run this code with the query "What's the weather like in Tokyo right now?", the AI will: 
 
 
 
 
 
 
 Recognize it needs weather data 
 
 Call the   function with "Tokyo" as the location get_weather 
 
 Receive the weather data 
 
 Generate a natural response with the information Anstatt Wetterinformationen zu erraten oder aufzustellen, liefert es reale Daten durch die Funktion. ️ Die Ausgabe: Wetterfunktion ruft in Aktion Wenn wir unser Wetterbeispiel mit der Abfrage "Wie ist das Wetter in Tokio gerade?" ausführen, kommt die Magie der Funktion zum Leben. Das Modell erkennt zuerst, dass dies eine Wetteranfrage ist und strukturiert einen Funktionsaufruf mit Parametern: Dieses formatierte JSON wird an unsere Funktion, die die mock Wetterdaten abruft, die wir definiert haben: eine Temperatur von 24°C und "Sunny" Bedingungen. {"location": "Tokyo", "unit": "celsius"} get_weather Wollen Sie OpenAI anstelle von Azure OpenAI verwenden? Der Hauptunterschied zwischen und   Die Umsetzung liegt in Mit OpenAI verwenden Sie den Standardclient mit einem direkten API-Schlüssel, während Azure OpenAI seinen spezifischen Client zusammen mit zusätzlichen Parametern wie und Bei Funktionsaufrufen verweist OpenAI auf Modelle mit ihren Standardnamen, während Azure OpenAI erfordert, dass Sie den Implementierungsnamen verwenden, den Sie in Ihrem Azure-Portal erstellt haben. OpenAI Azure OpenAI how you initialize the client azure_endpoint api_version Hier der Code Vergleich: # Standard OpenAI implementation
from openai import OpenAI

# Initialize the client
client = OpenAI(
    api_key="your-openai-api-key"
)

# Make an API call
response = client.chat.completions.create(
    model="gpt-4o",  # Standard model name
    messages=[{"role": "user", "content": "What's the weather in Seattle?"}],
    tools=functions,
    tool_choice="auto"
)
 # Azure OpenAI implementation
from openai import AzureOpenAI

# Initialize the client - requires more parameters
client = AzureOpenAI(
    api_key="your-azure-openai-api-key",
    api_version="2023-07-01-preview",  # Azure-specific
    azure_endpoint="https://your-resource-name.openai.azure.com"  # Azure-specific
)

# Make an API call
response = client.chat.completions.create(
    model="your-deployed-model-name",  # The name you gave your deployment in Azure
    messages=[{"role": "user", "content": "What's the weather in Seattle?"}],
    tools=functions,
    tool_choice="auto"
)
 Die neue Welt der Möglichkeiten Funktionsanruf hat alles verändert. AI kann jetzt: 
 
 
 
 
 
 
 
 
 Book real appointments 
 
 Look up real-time data 
 
 Control smart home devices 
 
 Query databases 
 
 Process payments 
 
 And much more Es ist der Unterschied zwischen einer KI, die über die Welt sprechen kann, und einer, die tatsächlich mit ihr interagieren kann. Das nächste Mal, wenn Sie einen Chatbot um die heutigen Nachrichten bitten oder Ihre Lichter einschalten, denken Sie daran: Es ist die Funktion des Anrufs, die die Magie hinter den Kulissen macht. Zusammenfassend Funktionelle Anrufe überbrücken die Lücke zwischen menschlicher Sprache und Computersystemen. Es ermöglicht der KI zu verstehen, wann sie externe Tools und Dienste mithilfe richtig formatierter Daten anrufen soll – egal ob Sie OpenAI direkt oder den OpenAI-Dienst von Azure verwenden. Wir haben untersucht, wie sie die KI von passiven Antworten zu aktiven Agenten verwandelt, die auf natürlichen Sprachanfragen konkret handeln können. Beide Plattformen unterstützen diese revolutionäre Fähigkeit, obwohl sie sich in Implementierungsdetails, Sicherheitsmodellen und Ökosystemintegration unterscheiden. Vorwärts blicken Die wahre Kraft des Funktionsaufrufs liegt nicht in dem, was es heute tun kann, sondern in dem, was es morgen ermöglicht.Da mehr Systeme API-Endpunkte aufdecken und sich Authentifizierungs- und Sicherheitsstandards entwickeln, nähern wir uns einer Welt, in der natürliche Sprache zu einer universellen Schnittstelle für digitale Systeme wird. Der letzte Gedanke Die wahre Revolution ist nicht nur, dass KI jetzt Handlungen ergreifen kann - es ist, dass die Barriere zwischen Denken und Tun auflöst. Funktionsanruf ist nicht nur ein technisches Merkmal; es ist der Moment, in dem die KI über die Seite und in die Welt hinausgeht und sich von einem Beobachter in einen Teilnehmer verwandelt.

This story contains new, firsthand information uncovered by the writer.

Books authored by me

Microsoft BUILD Session

PyCloud: Identifying defaulters using Machine Learning

Panel Discussion on Futuristic Technology and Possibilities

AI DEV DAYS: Integrating AI to Blockchain-Based Applications by Ritesh Modi

Understanding & Optimizing Dockerfiles by Ritesh Modi at Bangalore Container Conference 2017

Read My Stories

Dieses Audio ist in der Originalsprache der Geschichte produziert!

Müde von gebrochenen Chatbots? Dieses AI-Upgrade behebt alles

About Author

KOMMENTARE

Hängeetiketten

DIESER ARTIKEL WURDE VORGESTELLT IN

Related Stories

HackerNoon Decoded 2024: Wir feiern unsere Remote-Work-Community!

HackerNoon's DeFi Writing Contest with SORA Network: XSTUSD Use Cases

HackerNoon Decoded 2024: Celebrating Our Cybersecurity Community!

HackerNoon Decoded 2024: Wir feiern unsere Gaming-Community!

HackerNoon Decoded 2024: Wir feiern unsere Remote-Work-Community!

HackerNoon's DeFi Writing Contest with SORA Network: XSTUSD Use Cases

HackerNoon Decoded 2024: Celebrating Our Cybersecurity Community!

HackerNoon Decoded 2024: Wir feiern unsere Gaming-Community!

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps