Currency Exchange API for AI Agents: How to Build Real-Time Forex Tool Calling with LLMs

// AI Agent: Currency Conversion with OpenAI Function Calling
import OpenAI from 'openai';

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// Define the currency conversion tool schema
const currencyTool = {
  type: 'function' as const,
  function: {
    name: 'convert_currency',
    description: 'Convert an amount from one currency to another using live exchange rates',
    parameters: {
      type: 'object',
      properties: {
        from: {
          type: 'string',
          description: 'Source currency code (ISO 4217), e.g. USD, EUR, GBP',
        },
        to: {
          type: 'string',
          description: 'Target currency code (ISO 4217), e.g. JPY, CAD, AUD',
        },
        amount: {
          type: 'number',
          description: 'Amount to convert',
        },
      },
      required: ['from', 'to', 'amount'],
    },
  },
};

// Tool handler: calls Currency-Exchange.app API
async function convertCurrency(
  from: string,
  to: string,
  amount: number
) {
  const response = await fetch(
    'https://currency-exchange.app/api/v1/convert',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': process.env.FX_API_KEY,
      },
      body: JSON.stringify({ from, to, amount }),
    }
  );
  const data = await response.json();
  return {
    from,
    to,
    amount,
    rate: data.rate,
    result: data.result,
    timestamp: new Date().toISOString(),
  };
}

// Agent loop: handle multi-turn conversations with tool use
async function runCurrencyAgent(userMessage: string) {
  const messages: OpenAI.Chat.ChatCompletionMessageParam[] = [
    {
      role: 'system',
      content: `You are a helpful financial assistant. When users ask
about currency conversion, use the convert_currency tool to get
live rates. Present results clearly with the rate, converted
amount, and a brief note about the rate direction.`,
    },
    { role: 'user', content: userMessage },
  ];

  // Loop until the model stops requesting tool calls
  while (true) {
    const response = await openai.chat.completions.create({
      model: 'gpt-4o',
      messages,
      tools: [currencyTool],
      tool_choice: 'auto',
    });

    const choice = response.choices[0];
    messages.push(choice.message);

    if (choice.finish_reason === 'tool_calls') {
      for (const toolCall of choice.message.tool_calls || []) {
        const args = JSON.parse(toolCall.function.arguments);
        const result = await convertCurrency(
          args.from, args.to, args.amount
        );
        messages.push({
          role: 'tool',
          tool_call_id: toolCall.id,
          content: JSON.stringify(result),
        });
      }
    } else {
      return choice.message.content;
    }
  }
}

# AI Agent: Currency Conversion with Anthropic Claude Tool Use
import anthropic

client = anthropic.Anthropic(api_key=os.environ["ANTHROPHIC_API_KEY"])

# Define the currency conversion tool
currency_tool = {
    "name": "convert_currency",
    "description": (
        "Convert an amount between two currencies using live "
        "forex rates. Supports 150+ currencies with sub-50ms "
        "response times."
    ),
    "input_schema": {
        "type": "object",
        "properties": {
            "from": {
                "type": "string",
                "description": "Source currency (ISO 4217)"
            },
            "to": {
                "type": "string",
                "description": "Target currency (ISO 4217)"
            },
            "amount": {
                "type": "number",
                "description": "Amount to convert"
            }
        },
        "required": ["from", "to", "amount"]
    }
}

async def call_currency_api(from_curr: str, to_curr: str,
                            amount: float) -> dict:
    """Handler: calls Currency-Exchange.app API."""
    async with aiohttp.ClientSession() as session:
        async with session.post(
            "https://currency-exchange.app/api/v1/convert",
            headers={
                "Content-Type": "application/json",
                "x-api-key": os.environ["FX_API_KEY"],
            },
            json={"from": from_curr, "to": to_curr,
                  "amount": amount},
        ) as resp:
            data = await resp.json()
            return {
                "from": from_curr,
                "to": to_curr,
                "amount": amount,
                "rate": data["rate"],
                "result": data["result"],
                "timestamp": datetime.utcnow().isoformat(),
            }

async def run_currency_agent(user_message: str):
    """Run a multi-turn currency agent with Claude."""
    messages = [
        {"role": "user",
         "content": "Convert 1000 USD to JPY and tell me "
                    "if it's a good time to buy JPY."},
    ]

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        tools=[currency_tool],
        messages=messages,
    )

    # Process tool calls
    for block in response.content:
        if block.type == "tool_use":
            result = await call_currency_api(
                block.input["from"],
                block.input["to"],
                block.input["amount"],
            )
            # Send tool result back to Claude
            response = client.messages.create(
                model="claude-sonnet-4-20250514",
                max_tokens=1024,
                tools=[currency_tool],
                messages=messages + [
                    {"role": "assistant",
                     "content": [block]},
                    {"role": "user",
                     "content": [
                         {"type": "tool_result",
                          "tool_use_id": block.id,
                          "content": str(result)}
                     ]},
                ],
            )

    # Extract final text response
    for block in response.content:
        if hasattr(block, "text"):
            return block.text

// AI Agent: Batch Currency Conversion for E-commerce Pricing
interface BulkConversionRequest {
  from: string;
  to: string;
  amount: number;
  productId: string;
}

async function batchConvertProducts(
  products: BulkConversionRequest[]
): Promise<Map<string, number>> {
  // Process in parallel with concurrency limit of 10
  const results = new Map<string, number>();
  const concurrencyLimit = 10;

  for (let i = 0; i < products.length; i += concurrencyLimit) {
    const batch = products.slice(i, i + concurrencyLimit);
    const promises = batch.map(async (product) => {
      const response = await fetch(
        'https://currency-exchange.app/api/v1/convert',
        {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'x-api-key': process.env.FX_API_KEY,
          },
          body: JSON.stringify({
            from: product.from,
            to: product.to,
            amount: product.amount,
          }),
        }
      );
      const data = await response.json();
      return { productId: product.productId, result: data.result };
    });

    const batchResults = await Promise.all(promises);
    batchResults.forEach(({ productId, result }) => {
      results.set(productId, result);
    });
  }

  return results;
}

// Usage: Convert 10,000 products to local currency
// 10,000 products / 10 concurrent = 1,000 batches
// At <50ms per call, total time: ~5 seconds
const localPrices = await batchConvertProducts(
  productCatalog.map((p) => ({
    from: 'USD',
    to: userCurrency,
    amount: p.priceUsd,
    productId: p.id,
  }))
);

# Quick test: Convert currency via API
curl -X POST https://currency-exchange.app/api/v1/convert \
  -H "Content-Type: application/json" \
  -H "x-api-key: your-api-key" \
  -d '{"from": "USD", "to": "EUR", "amount": 100}'

# Response: {"rate": 0.9218, "result": 92.18}

# Fetch live rate for agent display
curl -X POST https://currency-exchange.app/api/v1/convert \
  -H "Content-Type: application/json" \
  -H "x-api-key: your-api-key" \
  -d '{"from": "USD", "to": "EUR", "amount": 1}'

# Response: {"rate": 0.9218, "result": 0.9218}