﻿次世代AIモデルプログラミング入門


掲載リスト






リスト2-1
!pip install anthropic -q


リスト2-2
from google.colab import userdata


ANTHROPIC_API_KEY = userdata.get('ANTHROPIC_API_KEY')


リスト2-3
import anthropic


client = anthropic.Anthropic(
  api_key=ANTHROPIC_API_KEY,
)
client


リスト2-4
prompt = "あなたは誰？" # @param {"type":"string"}


message = {
  "role": "user",
  "content": prompt
}


result = client.messages.create(
  model="claude-3-5-sonnet-20240620",
  max_tokens=1000,
  temperature=0.7,
  messages=[ message ]
)
result


リスト2-5
print(result.content[0].text)


リスト2-6
prompt = "自己紹介して下さい。" # @param {"type":"string"}


sys_prompt = '''漢字はそのままに、ひらがなをカタカナに、
カタカナをひらがなで答えて下さい。'''
messages = [
  {
    "role": "user",
    "content": "あなたの名前は？"
  },
  {
    "role": "assistant",
    "content": "私ノ名前ハ、くろーどデス。"
  },
  {
    "role": "user",
    "content": prompt
  }
]


result = client.messages.create(
  model="claude-3-5-sonnet-20240620",
  max_tokens=1000,
  temperature=0.7,
  system = sys_prompt,
  messages= messages
)
result.content[0].text


リスト2-7
messages = []
print("*** start ***")


while(True):
  prompt = input("prompt: ")
  if prompt == "":
    break
  messages.append({
    "role": "user",
    "content": prompt
  })
  result = client.messages.create(
    model="claude-3-haiku-20240307",
    max_tokens=1024,
    temperature=0.7,
    messages= messages
  )
  content = result.content[0].text
  print("assistant: ", content)
  messages.append({
    "role": "assistant",
    "content": content
  })


print("*** finished. ***")


リスト2-8
import requests
import base64


def get_image_as_base64(url):
  try:
    response = requests.get(url, stream=True)
    response.raise_for_status()
    img_data = response.content
    return base64.b64encode(img_data).decode('utf-8')


  except requests.exceptions.RequestException as e:
    print(f"エラーが発生しました: {e}")
    return None


リスト2-9
image_url = "https://picsum.photos/id/1008/1000/1000" # @param {"type":"string"}
prompt = "この画像について日本語で説明してください。" # @param {"type":"string"}


base64_image = get_image_as_base64(image_url)


if base64_encoded_image:
  result = client.messages.create(
    model="claude-3-5-sonnet-20240620",
    max_tokens=1024,
    temperature=0.7,
    messages=[
      {
        "role": "user",
        "content": [
          {
            "type": "image",
            "source": {
              "type": "base64",
              "media_type": "image/jpeg",
              "data": base64_image,
            },
          },
          {
            "type": "text",
            "text": prompt
          }
        ],
      }
    ],
  )
result.content[0].text


リスト2-10
prompt = "LLMについて説明して下さい。" # @param {"type":"string"}


message = {
  "role": "user",
  "content": prompt
}
with client.messages.stream(
  max_tokens=1024,
  temperature=0.7,
  messages=[message],
  model="claude-3-5-sonnet-20240620",
) as stream:
  for text in stream.text_stream:
    print(text, end="", flush=True)


リスト2-11
import random


def get_weather(location):
  weather = ["晴れ", "曇り", "雨", "雪"]
  temperature = list(range(-10, 31))
  random_weather = random.choice(weather)
  random_temperature = random.choice(temperature)
  print('*** weather report ***')
  print('location: ', location)
  print('weather: ', random_weather)
  print('temperature: ', random_temperature, 'c.')
  print('*** finished ***')


リスト2-12
weather_tool = {
  "name": "get_weather",
  "description": "指定された場所の現在の天気を取得します",
  "input_schema": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "都市と州、例: San Francisco, CA"
      }
    },
    "required": ["location"]
  }
}


リスト2-13
prompt = "東京の天気は？" # @param {"type":"string"}


// プロンプトを実行
response = client.messages.create(
  model="claude-3-5-sonnet-20240620",
  max_tokens=1024,
  tools=[weather_tool],
  messages=[{"role": "user", "content": prompt}]
)


// ツールを利用するか確認
if response.stop_reason == "tool_use":
  tool_use = response.content[-1]
  tool_name = tool_use.name
  tool_input = tool_use.input


  if tool_name == "get_weather":
    location = tool_input["location"]
    print(response.content[0].text)
    get_weather(location)
  elif response.stop_reason == "end_turn":
    print("<<< Claudeはツールを使いません。>>> ")
    print("応答結果: ")
    print(response.content[0].text)
else:
  print("<<< Claudeはツールを使いません。>>> ")
  print("応答結果: ")
  print(response.content[0].text)


リスト2-14
response = client.messages.create(
  model="claude-3-5-sonnet-20240620",
  max_tokens=1024,
  tool_choice={"type":"any"},
  tools=[weather_tool],
  messages=[{"role": "user", "content": prompt}]
)


リスト2-15
cd Desktop
mkdir claude-app
cd claude-app
npm init -y


リスト2-16
npm install dotenv @anthropic-ai/sdk


リスト2-17
ANTHROPIC_API_KEY=《APIキー》


リスト2-18
const readline = require('readline');


function prompt(msg){
  const read = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });
  
  return new Promise((resolve, reject)=>{
    read.question(msg, (answer) => {
      resolve(answer);
      read.close();
    });
  })
};


module.exports.prompt = prompt;


リスト2-19
const Anthropic = require("@anthropic-ai/sdk");
require('dotenv').config();
const { prompt } = require('./prompt.js');


const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;


const anthropic = new Anthropic({
  apiKey: ANTHROPIC_API_KEY,
});


// メイン関数
async function main() {
  const answer = await prompt('prompt: ');
  await accessToClaude(answer);
}


// AIアクセス関数
async function accessToClaude(content) {
  const message = {
    "role": "user",
    "content": [
      {
        "type": "text",
        "text": content
      }
    ]
  }
  const result = await anthropic.messages.create({
    model: "claude-3-5-sonnet-20240620",
    max_tokens: 1024,
    temperature: 0.7,
    messages: [message]
  });
  console.log(result.content); // ☆
}


main();


リスト2-20
// メイン関数
async function main() {
  const messages = [];
  while (true) {
    const input = await prompt('prompt: ');
    if (!input) {
      break;
    }
    messages.push({
      role: "user",
      content: input
    });
    const result = await accessToClaude(messages);
    const answer = result[0].text;
    console.log("assistant: " + answer);
    messages.push({
      role: "assistant",
      content: answer
    });
  }
}


// AIアクセス関数
async function accessToClaude(messages) {
  const sysPrompt = `あなたはシェークスピアアシスタントです。
    シェークスピアの戯曲の登場人物のように日本語で話して下さい。`;
  const result = await anthropic.messages.create({
    model: "claude-3-5-sonnet-20240620",
    max_tokens: 1024,
    temperature: 0.7,
    system: sysPrompt,
    messages: messages
  });
  return result.content;
}


リスト2-21
const fs = require('fs');


// 画像をBase64エンコードする関数
function encodeImageToBase64(filePath) {
  const data = fs.readFileSync(filePath);
  return data.toString('base64');
}


リスト2-22
async function main() {
  const fpath = await prompt("filepath: ");
  const input = await prompt("prompt: ");
  const result = await accessToClaude(input, fpath);
  console.log(result[0].text);
}


async function accessToClaude(prompt, fpath) {
  const base64Data = await encodeImageToBase64(fpath);
  const messages = [
    {
      role: "user",
      content: [
        {
          type: "image",
          source: {
            type: "base64",
            media_type: "image/jpeg",
            data: base64Data,
          },
        },
        {
          type: "text",
          text: prompt
        }
      ]
    }
  ];
  const result = await anthropic.messages.create({
    model: "claude-3-5-sonnet-20240620",
    max_tokens: 1024,
    temperature: 0.7,
    messages: messages
  });
  return result.content;
}


リスト2-23
async function main() {
  const input = await prompt("prompt: ");
  await accessToClaude(input);
}


async function accessToClaude(prompt) {
  await anthropic.messages.stream({
    model: 'claude-3-5-sonnet-20240620',
    max_tokens: 1024,
    temperature: 0.7,
    messages: [
      {role: 'user', content: prompt}
    ],
  }).on('text', (text) => {
    process.stdout.write(text);
  });
}


リスト2-24
const Anthropic = require("@anthropic-ai/sdk");
require('dotenv').config();
const { prompt } = require('./prompt.js');


const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;


const anthropic = new Anthropic({
  apiKey: ANTHROPIC_API_KEY,
});


// 天気を取得するツール関数
const getWeather = (location) => {
  const weatherOptions = ["晴れ", "曇り", "雨", "雪"];
  const temperatureRange = Array.from(
      { length: 42 }, (_, i) => i - 10);
  
  const randomWeather = weatherOptions[
      Math.floor(Math.random() * weatherOptions.length)];
  const randomTemperature = temperatureRange[
      Math.floor(Math.random() * temperatureRange.length)];
  
  console.log('*** weather report ***');
  console.log('location: ', location);
  console.log('weather: ', randomWeather);
  console.log('temperature: ', randomTemperature, 'c.');
  console.log('*** finished ***');
};


/// 天気を取得するツール関数の定義
const weatherTool = {
  name: "get_weather",
  description: "指定された場所の現在の天気を取得します",
  input_schema: {
    type: "object",
    properties: {
      location: {
        type: "string",
        description: "都市と州、例: San Francisco, CA"
      }
    },
    required: ["location"]
  }
};


// メイン関数
async function main() {
  const input = await prompt("prompt: ");
  await accessToClaude(input);
}


// Claudeにアクセスする関数
async function accessToClaude(prompt) {
  const response = await anthropic.messages.create({
    model: 'claude-3-5-sonnet-20240620',
    max_tokens: 1024,
    temperature: 0.7,
    messages: [
      {role: 'user', content: prompt}
    ],
    tools: [weatherTool]
  });


  // ツールを使用した場合の処理
  if (response.stop_reason === "tool_use") {
    const toolUse = response.content[1];
    const toolName = toolUse.name;
    const toolInput = toolUse.input;
  
    // get_weatherツールの場合の処理
    if (toolName === "get_weather") {
      console.log(response.content[0].text);
      const location = toolInput.location;
      getWeather(location);
    }
  // ツールを使用しなかった場合の処理
  } else if (response.stop_reason === "end_turn") {
    console.log("<<< Claudeはツールを使っていません。>>> ");
    console.log("応答結果: ");
    console.log(response.content[0]);
  }
}


main();


リスト2-25
curl https://api.anthropic.com/v1/messages --header "x-api-key:《APIキー》" --header "anthropic-version: 2023-06-01" --header "content-type: application/json" --data '{"model":"claude-3-5-sonnet-20240620","max_tokens":1024,"messages":[{"role":"user","content":"あなたは誰？"}]}'


リスト2-26
function myFunction() {
  const userProperties = PropertiesService.getUserProperties();
  userProperties.setProperty('CLAUDE_API_KEY', '《APIキー》');
}


リスト2-27
// APIキーの準備
const userProperties = PropertiesService.getUserProperties();
const apiKey = userProperties.getProperty('CLAUDE_API_KEY');


// エンドポイント
const URL = 'https://api.anthropic.com/v1/messages';


// メイン関数
function myFunction () {
  const prompt = "あなたは誰？";  //Browser.inputBox("prompt:");
  console.log(prompt);
  const result = access_claude(prompt);
  console.log(result.content[0].text);
}


// APIアクセス関数
function access_claude(prompt) {
  var response = UrlFetchApp.fetch(URL, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-key": apiKey,
      "anthropic-version": "2023-06-01"
    },
    payload: JSON.stringify({
      model:"claude-3-5-sonnet-20240620",
      max_tokens:1024,
      messages:[
        {role:"user",content:prompt}
      ]
    })
  });
  return JSON.parse(response.getContentText());
}


リスト3-1
from google.colab import userdata


COHERE_API_KEY = userdata.get('COHERE_API_KEY')


リスト3-2
!pip install cohere -q -U


リスト3-3
import cohere
import json


co = cohere.Client(COHERE_API_KEY)
co


 これで変数coにClientインスタンスが代入されました。APIへのアクセスは、このClientに用リスト3-4
message = "" # @param {type:"string"}


response = co.chat(
  model='command-r-plus',
  message=message,
)


response


リスト3-5
response.text


リスト3-6
message = "あなたは誰ですか？" # @param {type:"string"}


response = co.chat(
  model='command-r-plus',
  message=message,
  chat_history=[
    {
      "role": "SYSTEM", 
      "message": "あなたは俳人です。最後に必ず一句つけて下さい。"
    },
    {
      "role": "USER", 
      "message": "こんにちは。お元気ですか。"
    },
    {
      "role": "CHATBOT", 
      "message": "もちろん、元気ですよ！ 秋空や 今日も一日 元気よく"
    },
  ]
)


print(response.text)


リスト3-7
message = "あなたは誰ですか？" # @param {type:"string"}


response = co.chat(
  model='command-r-plus',
  message=message,
  temperature=0.7,
  max_tokens=100,
  presence_penalty=0.5,
  safety_mode='STRICT'
)


response.text


リスト3-8
prompt = "佐倉市の名所は？" # @param {type:"string"}


response = co.chat(
  model="command-r-plus",
  message=prompt,
  connectors=[{
    "id": "web-search",
    "options":{"site":"https://ja.wikipedia.org/"}
  }]
)
print(response.text)


リスト3-9
for citation in response.citations:
  print(citation.text,citation.document_ids)
print()
for document in response.documents:
  print(document['id'],': ', document['snippet'][:50])


リスト3-10
def python_terpreter(python_code):
  exec(python_code)


リスト3-11
python_interpreter_definition = {
  "name": "python_terpreter",
  "description": "Executes Python code and returns the output.",
  "parameters": {
    "type": "object",
    "properties": {
      "python_code": {
        "type": "string",
        "description": "The Python code to execute."
      }
    },
    "required": ["python_code"]
  }
}


リスト3-12
python_code = """
def calculate_sum(numbers):
  total = 0
  for number in numbers:
    total += number
  return total
  
numbers = {array}
result = calculate_sum(numbers)
print("合計:", result)
"""


リスト3-13
code = python_code.format(array=[12,34,56,78,90])


# python_interpreterツールを使用してコードを実行
response = co.chat(
  model="command-r-plus",
  message=code,
  tools=[python_interpreter_definition]
)
response


リスト3-14
print("実行結果:")
if response.tool_calls !=  None:
  for tool_call in response.tool_calls:
    if tool_call.name == "python_terpreter":
      print('<<< python_terpreter >>>')
      print('---- code ----')
      print(tool_call.parameters['python_code'])
      print('---- result ----')
      python_terpreter(tool_call.parameters['python_code'])
else:
  print('*** no tools used ***')
  print(response.text)


リスト3-15
message = "" # @param {"type":"string"}


response = co.chat_stream(
  model="command-r-plus",
  message=message,
)


chars = set(",.!?、。！？")  #改行する文字


for event in response:
  if event.event_type == "text-generation":
    if set(event.text) & chars:
      print(event.text)
    else:
      print(event.text, end="")


リスト3-16
train_examples = [
  {"text": "この映画は素晴らしかった！とても感動した。", "label": "ポジティブ"},
  {"text": "料理がおいしくて、サービスも良かった。", "label": "ポジティブ"},
  {"text": "全然面白くなかった。時間の無駄だった。", "label": "ネガティブ"},
  {"text": "接客が悪く、二度と行きたくない。", "label": "ネガティブ"},
  {"text": "普通だった。特に良くも悪くもない。", "label": "中立"},
  {"text": "まあまあだけど、期待ほどではなかった。", "label": "中立"}
]


リスト3-17
inputs = [
  "最高の体験だった！絶対にまた行きたい。",
  "期待外れだった。行ったのは失敗だった。",
  "悪くはないけど、特に印象に残るものはなかった。"
]


リスト3-18
response = co.classify(
  model='embed-multilingual-v3.0',
  inputs=inputs,
  examples=train_examples,
)
response


リスト3-19
# 結果の表示
for classification in response.classifications:
  print("テキスト:", classification.input)
  print("予測ラベル:", classification.prediction)
  print("信頼度:", classification.confidence)
  print()


リスト3-20
docs = [
  'カーソンシティはネバダ州の州都です。',
  '日本の首都は東京です。',
  '北マリアナ諸島の首都はサイパンです。',
  'アメリカ合衆国の首都は、ニューヨークではありません。',
  'ワシントンD.C.はアメリカ合衆国の首都です。',
  'ワシントンD.C.は連邦直轄区です。'
  '死刑制度のある州は2017年時点で50州のうち30州です。'
]


リスト3-21
query = 'アメリカ合衆国の首都はどこですか?' # @param {"type":"string"}


response = co.rerank(
  query=query,
  documents=docs,
  top_n=3, # 上位3項目
  return_documents=True,
  model='rerank-multilingual-v3.0'
)
response


リスト3-22
# 結果の表示
for result in response.results:
  print(result.document.text, '[',result.relevance_score,']')


リスト3-23
cd Desktop
mkdir cohere-app
cd cohere-app
npm init -y


リスト3-24
npm install dotenv cohere-ai


リスト3-25
COHERE_API_KEY=《APIキー》


リスト3-26
const { CohereClient } = require("cohere-ai");
require('dotenv').config();
const { prompt } = require('./prompt.js');


const COHERE_API_KEY = process.env.COHERE_API_KEY;


const cohere = new CohereClient({
  token: COHERE_API_KEY,
});


const main = () => {
  prompt("prompt: ").then((input)=> {
    cohere.chat({
      message: input,
    }).then((response) => {
      console.log(response); //☆
    });
  });
 };


main();


リスト3-27
const main = async () => {
  const input = await prompt("prompt: ");
  const response = await cohere.chat({
    model:'c4ai-aya-23-35b',
    message: input,
  });
  console.log(response.text);
};


リスト3-28
const main = async () => {
  const input = await prompt("prompt: ");
  accessToAI(input);
};


const accessToAI = (input) => {
  cohere.chat({
    model:'c4ai-aya-23-35b',
    message: input,
  }).then(response=>{
    console.log(response.text);
  });
}


リスト3-29
const main = async () => {
  const input = await prompt("prompt: ");
  const response = await cohere.chat({
    model:'command-r',
    message: input,
    temperature:0.7,
    max_tokens:100,
    presence_penalty:0.5
  });
  console.log(response.text);
};


リスト3-30
const main = async () => {
  const input = await prompt("prompt: ");
  const response = await cohere.chat({
    model:'command-r',
    preamble:`あなたはカトリックの神父です。
    聖書を引用して会話して下さい。`,
    chatHistory:[
      { 
        role: 'USER', 
        message: 'お腹が空いた。何か食べ物を下さい。' 
      },
      {
        role: 'CHATBOT',
        message: '求めよ、さらば与えられん。（マタイ福音書7章7節）',
      },
    ],
    message: input,
    temperature:0.7,
    max_tokens:100
  });
  console.log(response.text);
};


リスト3-31
const main = async () => {
  const input = await prompt("prompt: ");
  const chatStream = await cohere.chatStream({
    model:'command-r',
    message: input,
    temperature:0.7,
    max_tokens:1000
  });


  for await (const message of chatStream) {
    if (message.eventType === 'text-generation') {
      process.stdout.write(message.text);
    } else {
      console.log('[',message.eventType,']');
    }
  }
}


リスト3-32
const main = async () => {
  const input = await prompt("prompt: ");
  const response = await cohere.chat({
    model:'command-r',
    message: input,
    temperature:0.7,
    max_tokens:1000,
    connectors:[{
      id:"web-search",
      options:{site:"http://ja.wikipedia.org/"}
    }]
  });
  console.log(response.text);
  console.log('<< 引用 >>');
  for (citation of response.citations) {
    console.log(citation.text.slice(0, 25),citation.documentIds);
  }
  console.log('<<ドキュメント>>');
  for (document of response.documents) {
    console.log(document.id,': ', document.snippet.slice(0, 25));
  }
}


リスト3-33
function findZodiacIndex(zodiac) {
  const zodiacSigns = [
    ["おひつじ座", "牡羊座", "Aries"],
    ["おうし座", "牡牛座", "Taurus"],
    ["ふたご座", "双子座", "Gemini"],
    ["かに座", "蟹座", "Cancer"],
    ["しし座", "獅子座", "Leo"],
    ["おとめ座", "乙女座", "Virgo"],
    ["てんびん座", "天秤座", "Libra"],
    ["さそり座", "蠍座", "Scorpio"],
    ["いて座", "射手座", "Sagittarius"],
    ["やぎ座", "山羊座", "Capricorn"],
    ["みずがめ座", "水瓶座", "Aquarius"],
    ["うお座", "魚座", "Pisces"]
  ];
  for (let i = 0; i < zodiacSigns.length; i++) {
    if (zodiacSigns[i].includes(zodiac)) {
      return i;
    }
  }
  return -1;  // 見つからなかった場合
}


リスト3-34
function getFortune(zodiac) {
  const zodiacNum = findZodiacIndex(zodiac);
  if (zodiacNum < 0) {
    return "星座が見つかりません。";
  }
  const fortunes = [
    '今日は積極性が吉！新しいことに挑戦しよう', 
    '運気が上昇中！何もかも快適な一日になりそう',
    '今日は安定を求めよう。いつもと同じが一番', 
    '一日のんびりとリラックス。慌てない慌てない', 
    '金運アップのチャンス。一攫千金も今日なら？',
    '何をやってもうまくいかない……こんな日もあるよね',
    'ゆっくり運気が下降。新しいことは明日まで我慢',
    '今日はラッキーデーかも！一日楽しく過ごせるよ',
    '思わぬ出会いがあるかも。まわりをよく見てごらん？',
    '今日は穏やかに過ごそう。急な変化にはご用心',
    '新しいことに挑戦してみよう。今日ならうまくいくかも',
    '今日は変化の日！いつもと違うことを試してみよう'
  ];
  const day = parseInt(Date.now() / (1000 * 60 * 60 * 24));
  return fortunes[(day + zodiacNum) % 12];
}


リスト3-35
horoscope = {
  "name": "horoscope",
  "description": "日本の星座名をもとに今日の運勢を占います。",
  "parameters": {
    "type": "object",
    "properties": {
      "zodiac": {
        "type": "string",
        "description": "12星座の日本語の名前。例:おとめ座"
      }
    },
    "required": ["zodiac"]
  }
}


リスト3-36
const main = async () => {
  const input = await prompt("prompt: ");
  const response = await cohere.chat({
    message: input,
    temperature:0.7,
    max_tokens:1000,
    tools:[horoscope]
  });
  
  if (response.toolCalls) {
    const toolCall = response.toolCalls[0];
    if (toolCall.name === 'horoscope') {
      let zname = toolCall.parameters.zodiac;
      const fortune = getFortune(zname);
      if (toolCall.parameters.zodiac) {
        console.log('*** 今日の運勢 ***');
        console.log(toolCall.parameters.zodiac);
      }
      console.log(fortune);
    }
  } else {
    console.log('<<< no tool. >>>');
    console.log(response.text);
  }
}


リスト3-37
const examples = [
  [
    { text: "パーティーで注目の的になるのが好きです。", label: "外向的" },
    { text: "多くの人と会話することにエネルギーを感じます。", label: "外向的" },
    { text: "外に出かけるより家で過ごすのが好きです。", label: "内向的" },
    { text: "一人で過ごす時間に心地よさを感じます。", label: "内向的" }
  ],
  [
    { text: "グループプロジェクトでよくリーダーを務めます。", label: "リーダー" },
    { text: "チームをまとめ、目標に導くのが得意です。", label: "リーダー" },
    { text: "リーダーの指示やガイドラインに従って行動します。", label: "フォロワー" },
    { text: "他人の意見を尊重し従うことに安心感を覚えます。", label: "フォロワー" }
  ],
  [
    { text: "問題に対して創造的な解決策を考え出します。", label: "創造的" },
    { text: "新しいアイデアを生み出すことが得意です。", label: "創造的" },
    { text: "試行済みの確実な方法を好みます。", label: "実践的" },
    { text: "リスクよりも実績のあるアプローチを選びます。", label: "実践的" }
  ]
];


リスト3-38
const students = [
  "アリスです。イベントを企画したり新しい人と出会うのが大好きです。",
  "ボブです。家に帰って一人で好きなことに取り組むのが好きです。",
  "チャーリーです。学校のプロジェクトでよくユニークなアイデアを思いつきます。",
  "デイビッドです。リーダーの指示に従ってチームで働くのが得意です。",
  "イブです。グループディスカッションでは自分から発言するのが苦手です。"
];


リスト3-39
const main = async () => {
  const responses = [];
  for (let i = 0;i < 3;i++) {
    responses[i] = await cohere.classify({
      model:'embed-multilingual-v3.0',
      examples:examples[i],
      inputs:students,
      temperature:0.7,
      max_tokens:1000,
    });
  }
  
  // 結果の出力
  for(let i = 0;i < 5;i++) {
    const classifiation = responses[0].classifications[i];
    console.log(classifiation.input);
    process.stdout.write('[');
    for(let response of responses) {
      process.stdout.write(response.classifications[i].prediction)
    }
    process.stdout.write(']');
    console.log();
  }
}


リスト3-40
const documents = [
  'パリのノートルダム寺院は現在、火災からの復旧作業中です。',
  'エッフェル塔はパリ万国博覧会のために建設されました。',
  'パリの凱旋門はナポレオンの勝利を記念して作られました。',
  'フランスの大統領府エリゼ宮は1718年に建設されました。',
  'パリはフランスの首都で、220万人が暮らしています。',
  'パリで一番のフレンチレストランはGuy Savoyです。',
  'フランスのワインは世界で最も高く評価されています。',
  'パリのルーブル美術館は世界最大の美術館です。',
];


リスト3-41
const main = async () => {
  const query = await prompt('prompt: ');
  try {
    const response = await cohere.rerank({
      model: 'rerank-multilingual-v3.0',
      query: query,
      documents: documents,
      top_n: 5, // 上位5件を取得
    });


    response.results.forEach((result, index) => {
      if (index == 0) {
        console.log();
        console.log('*** 選択したドキュメント ***');
      } else if (index == 1) {
        console.log();
        console.log('### その他の候補 ###');
      }
      console.log(documents[result.index], 
        '[',result.relevanceScore,']');
    });
  } catch (error) {
    console.error('Error:', error);
  }
}


リスト3-42
curl https://api.cohere.com/v1/chat --header 'content-type: application/json' --header "Authorization: bearer 《APIキー》"   --data '{"model":"command-r-plus-08-2024", "message": "あなたは誰？"}'


リスト3-43
function myFunction() {
  const userProperties = PropertiesService.getUserProperties();
  userProperties.setProperty('COHERE_API_KEY', '《APIキー》');
}


リスト3-44
// APIキーの準備
const userProperties = PropertiesService.getUserProperties();
const apiKey = userProperties.getProperty('COHERE_API_KEY');


// エンドポイント
const URL = 'https://api.cohere.com/v1/chat';


// メイン関数
function myFunction () {
  const prompt = "あなたは誰？";  // ☆
  console.log(prompt);
  const result = access_claude(prompt);
  console.log(result.text);
}


// APIアクセス関数
function access_claude(prompt) {
  var response = UrlFetchApp.fetch(URL, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": "bearer " + apiKey
    },
    payload: JSON.stringify({
      model:"command-r-plus-08-2024",
      message:prompt
    })
  });
  return JSON.parse(response.getContentText());
}


リスト3-45
curl https://api.cohere.com/v1/rerank --header 'accept: application/json' --header 'content-type: application/json' --header "Authorization: bearer 《APIキー》" --data '{"model": "rerank-multilingual-v3.0","query": "日本の首都は？","top_n": 3,"documents": ["日本最大の都市は東京です。","日本の副都心は幕張です。","東京は日本の首都です。","ロンドンは英国の首都です。","千年間、日本の首都だったのは京都です。"]}'


リスト3-46
// APIキーの準備
const userProperties = PropertiesService.getUserProperties();
const apiKey = userProperties.getProperty('COHERE_API_KEY');


// エンドポイント
const URL = 'https://api.cohere.com/v1/rerank';


// ドキュメント
const documents = [
  "日本最大の都市は東京です。",
  "日本の副都心は幕張です。",
  "東京は日本の首都です。",
  "ロンドンは英国の首都です。",
  "千年間、日本の首都だったのは京都です。"
];


// メイン関数
function myFunction () {
  const prompt = "日本の首都は？";  //☆
  console.log(prompt);
  const results = access_claude(prompt);
  for (let result of results.results) {
    console.log(documents[result.index],'[', result.relevance_score, ']')
  }
}


// APIアクセス関数
function access_claude(prompt) {
  var response = UrlFetchApp.fetch(URL, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": "bearer " + apiKey
    },
    payload: JSON.stringify({
      model:"rerank-multilingual-v3.0",
      query:prompt,
      documents:documents,
      top_n:3
    })
  });
  return JSON.parse(response.getContentText());
}


リスト3-47
curl https://api.cohere.com/v1/rerank --header 'content-type: application/json' --header "Authorization: bearer 《APIキー》" --data '{"model":"embed-multilingual-v3.0","inputs": ["台風が接近しているので、外出時は注意が必要です。","最新のAI技術を活用したロボットが登場しました。","毎日のストレッチで体の柔軟性が向上しました。","今週末は新しい遊園地がオープンするそうです。"],"examples": [{"text": "今日は晴れて気温も高く、とても暑い一日でした。","label": "天気"},{"text": "明日は雨が降るそうです。傘を忘れずに。","label": "天気"},{"text": "新しいスマートフォンの機能が素晴らしいです。", "label": "テクノロジー"},{"text": "人工知能の発展により、多くの業界で革新が起きています。","label": "テクノロジー"},{"text": "健康的な食事と適度な運動が大切です。","label": "健康"},{"text": "十分な睡眠を取ることでストレス解消になります。","label": "健康"},{"text": "新作映画のストーリーが素晴らしかったです。","label": "エンターテイメント"},{"text": "昨晩のコンサートは最高の思い出になりました。","label": "エンターテイメント"}]


リスト3-48
// APIキーの準備
const userProperties = PropertiesService.getUserProperties();
const apiKey = userProperties.getProperty('COHERE_API_KEY');


// エンドポイント
const URL = 'https://api.cohere.com/v1/classify';


// 入力データ
const inputs = [
  "台風が接近しているので、外出時は注意が必要です。",
  "最新のAI技術を活用したロボットが登場しました。",
  "毎日のストレッチで体の柔軟性が向上しました。",
  "今週末は新しい遊園地がオープンするそうです。"
];


// 学習データ
const examples = [
  {"text": "今日は晴れて気温も高く、とても暑い一日でした。",
    "label": "天気"},
  {"text": "明日は雨が降るそうです。傘を忘れずに。",
      "label": "天気"},
  {"text": "新しいスマートフォンの機能が素晴らしいです。", 
    "label": "テクノロジー"},
  {"text": "人工知能の発展により、多くの業界で革新が起きています。",
      "label": "テクノロジー"},
  {"text": "健康的な食事と適度な運動が大切です。",
    "label": "健康"},
  {"text": "十分な睡眠を取ることでストレス解消になります。",
    "label": "健康"},
  {"text": "新作映画のストーリーが素晴らしかったです。",
    "label": "エンターテイメント"},
  {"text": "昨晩のコンサートは最高の思い出になりました。",
    "label": "エンターテイメント"}
];


// メイン関数
function myFunction () {
  const results = access_claude();
  for (let result of results.classifications) {
    console.log(result.input,'[',result.prediction,']');
  }
}


// APIアクセス関数
function access_claude() {
  var response = UrlFetchApp.fetch(URL, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": "bearer " + apiKey
    },
    payload: JSON.stringify({
      model:"embed-multilingual-v3.0",
      inputs:inputs,
      examples:examples
    })
  });
  return JSON.parse(response.getContentText());
}


リスト4-1
from google.colab import userdata


GROQ_API_KEY = userdata.get('GROQ_API_KEY')


リスト4-2
!pip install groq -q -U


リスト4-3
from groq import Groq


client = Groq(api_key=GROQ_API_KEY)
client 


リスト4-4
prompt = "あなたは誰？" # @param {"type":"string"}


response = client.chat.completions.create(
  model="llama3-8b-8192",
  messages=[
    {
      "role": "system",
      "content": "すべて日本語で答えて下さい。"
    },
    {
      "role": "user",
      "content": prompt
    }
  ],
  temperature=0.7,
  max_tokens=1024,
)
response


リスト4-5
response.choices[0].message.content


リスト4-6
import time
prompt = "あなたは誰？" # @param {"type":"string"}


response = client.chat.completions.create(
  model="llama3-8b-8192",
  messages=[
    {
      "role": "system",
      "content": "すべて日本語で答えて下さい。"
    },
    {
      "role": "user",
      "content": prompt
    }
  ],
  stream=True,
  temperature=1,
  max_tokens=1024,
)


chars = set(",.!?、。！？")  #改行する文字


for chunk in response:
  time.sleep(0.1) # ☆
  content = chunk.choices[0].delta.content
  if content == None:
    break 
  if set(content) & chars:
    print(chunk.choices[0].delta.content)
  else:
    print(chunk.choices[0].delta.content, end="")


リスト4-7
from groq import Groq
import json  # 後で使う


MODEL = 'llama3-groq-70b-8192-tool-use-preview'


# 数式を評価するツール関数
def calculate(expression):
  print("*** Evaluate a mathematical expression ***")
  try:
    result = eval(expression)
    return json.dumps({"result": result})
  except:
    return json.dumps({"error": "Invalid expression"})


リスト4-8
tools = [
  {
    "type": "function",
    "function": {
      "name": "calculate",
      "description": "expressionの数式を評価する関数です。",
      "parameters": {
        "type": "object",
        "properties": {
          "expression": {
            "type": "string",
            "description": "評価する数式。例: (1 + 2) * 3 / 4",
          }
        },
        "required": ["expression"],
      },
    },
  }
]


リスト4-9
def run(prompt):
  messages=[
    {
      "role": "system",
      "content": '''あなたは計算機アシスタントです。
      計算機能を使用して数学演算を実行し、結果を提供します。'''
    },
    {
      "role": "user",
      "content": prompt,
    }
  ]


  # toolsを指定してcreateを実行
  response = client.chat.completions.create(
    model=MODEL,
    messages=messages,
    tools=tools,
    tool_choice="auto",
    max_tokens=4096
  )


  # メッセージを得る
  resp_message = response.choices[0].message
  # tool_callsをチェック
  tool_calls = resp_message.tool_calls
  if tool_calls: # tool_callsの場合
    for tool_call in tool_calls:
      if tool_call.function.name == "calculate":
        # calculateの引数と関数を取得
        func_args = json.loads(tool_call.function.arguments)
        func_response = calculate(
          expression=func_args.get("expression")
        )
        print(func_response)


  else: # tool_callsでない場合
    print(response.choices[0].message.content)


# プロンプトを入力しrunを実行
prompt = "1 + 2 + 3 + 4 + 5" # @param {"type":"string"}
run(prompt)


リスト4-10
cd Desktop
mkdir groq-app
cd groq-app
npm init -y


リスト4-11
npm install dotenv groq-sdk


リスト4-12
GROQ_API_KEY=《APIキー》


リスト4-13
require('dotenv').config();
const { Groq } = require('groq-sdk');
const { prompt } = require('./prompt.js');


const groq = new Groq({
  api_key: process.env.GROQ_API_KEY
});


async function main() {
  const query = await prompt("prompt: ");
  const response = await groq.chat.completions.create({
    model: 'llama3-8b-8192',
    messages: [
      {
        role: 'system',
        content: 'すべて日本語で応答して下さい。'
      },
      {
        role: 'user',
        content: query
      }
    ],
  })
  console.log(response.choices[0].message.content);
}


main();


リスト4-14
async function main() {
  const query = await prompt("prompt: ");
  const response = await groq.chat.completions.create({
    model: 'llama3-8b-8192',
    messages: [
      {
        role: 'system',
        content: 'すべて日本語で応答して下さい。'
      },
      {
        role: 'user',
        content: query
      }
    ],
    stream: true
  });
  for await (const chunk of response) {
    if (chunk.choices[0]) {
      process.stdout.write(chunk.choices[0].delta.content || "");
    } else {
      break;
    }
  }
}


リスト4-15
require('dotenv').config();
const { Groq } = require('groq-sdk');
const { prompt } = require('./prompt.js');


const groq = new Groq({
  api_key: process.env.GROQ_API_KEY
});


// モデル名
const MODEL = 'llama3-groq-70b-8192-tool-use-preview';


// ツール用関数
function calculate(expression) {
  console.log("*** Evaluate a mathematical expression ***");
  try {
    const result = eval(expression);
    return { result: result };
  } catch (error) {
    return { error: "Invalid expression" };
  }
}


リスト4-16
const tools = [
  {
    type: "function",
    function: {
      name: "calculate",
      description: "expressionの数式を評価する関数です。",
      parameters: {
        type: "object",
        properties: {
          expression: {
            type: "string",
            description: "評価する数式。例: (1 + 2) * 3 / 4",
          }
        },
        required: ["expression"]
      }
    }
  }
];


リスト4-17
async function run(query) {
  const messages = [
    {
      role: "system",
      content: `あなたは計算機アシスタントです。
      計算機能を使用して数学演算を実行し、結果を提供します。`
    },
    {
      role: "user",
      content: query
    }
  ];


  try {
    // APIリクエストを送信
    const response = await groq.chat.completions.create({
      model: MODEL,
      messages: messages,
      tools: tools,
      tool_choice: "auto",
      max_tokens: 4096
    });
    
    // レスポンスを処理
    const respMessage = response.choices[0].message;
    const toolCalls = respMessage.tool_calls;
    
    // ツールの呼び出しをチェック
    if (toolCalls && toolCalls.length > 0) {
      // ツールの呼び出しを処理
      for (let toolCall of toolCalls) {
        // calucateの処理
        if (toolCall.function.name === "calculate") {
          const funcArgs = JSON.parse(toolCall.function.arguments);
          const funcResponse = calculate(funcArgs.expression);
          console.log(funcArgs.expression, ' = ', 
              funcResponse.result);
        }
      }
    } else { // ツールを使わない場合
      console.log(response.choices[0].message.content);
    }


  } catch (error) {
    console.error("Error in run function:", error.message);
  }
}


// プロンプトを入力してrunを実行
async function main() {
  const query = await prompt("prompt: ");
  run(query);
}
main();


リスト4-18
import ollama


prompt = input("prompt: ")


response = ollama.chat(
  model='llama3.2', 
  messages=[
    {
      'role': 'user',
      'content': prompt,
    },
  ])


print(response['message']['content'])


リスト4-19
import ollama


prompt = input("prompt: ")


response = ollama.generate('llama3.2', prompt)


print(response['response'])


リスト4-20
import ollama


prompt = input("prompt: ")


response = ollama.chat(
  model='llama3.2', 
  messages=[
    {
      'role': 'user',
      'content': prompt,
    },
  ],
  stream=True)


for part in response:
  print(part['message']['content'], end='', flush=True)
print()


リスト4-21
import ollama


prompt = input("prompt: ")


response = ollama.generate(
  model='llama3.2', 
  prompt=prompt,
  stream=True)


for part in response:
  print(part['response'], end='', flush=True)
print()


リスト4-22
npm install ollama


リスト4-23
const { prompt } = require('./prompt.js');
const { Ollama } = require('ollama');


const ollama = new Ollama();


async function main() {
  query = await prompt('prompt: ');
  const response = await ollama.chat({
    model: 'llama3.2',
    messages: [
      { 
        role: 'user',
        content: query
      }
    ],
  });
  console.log(response.message.content);
}


main();


リスト4-24
async function main() {
  query = await prompt('prompt: ');
  const response = await ollama.generate({
    model: 'llama3.2',
    prompt: query
  });
  console.log(response.response);
}


リスト4-25
async function main() {
  query = await prompt('prompt: ');
  const response = await ollama.chat({
    model: 'llama3.2',
    messages: [
      { 
        role: 'user',
        content: query
      }
    ],
    stream: true,
  });
  for await(const chunk of response) {
    process.stdout.write(chunk.message.content);
  }
}


リスト4-26
async function main() {
  query = await prompt('prompt: ');
  const response = await ollama.generate({
    model: 'llama3.2',
    prompt: query,
    stream: true,
  });
  for await(const chunk of response) {
    process.stdout.write(chunk.response);
  }
}


リスト4-27
curl http://localhost:11434/api/generate  --header 'content-type: application/json' --data '{ "model": "llama3.2", "prompt":"あなたは誰？", "stream:false }'


リスト4-28
curl http://localhost:11434/api/chat  --header 'content-type: application/json' --data '{ "model": "llama3.2", "messages": [ { "role": "user", "content": "あなたは誰？" } ], "stream":false }'


リスト4-29
python -m http.server


リスト4-30
<!DOCTYPE html>
<html>
  <head>
    <title>Ollama sample</title>
    <style>
    body {
        font-family: Arial, sans-serif;
        text-align: center;
      }
      p {
        margin: 25px 50px;
      }
      input {
        padding: 5px;
        margin-right: 5px;
        width: 300px;
      }
      button {
        padding: 5px 10px;
        background-color: #333;
        color: #fff;
      }
    </style>
  </head>
  <body>
    <h1>Ollama sample</h1>
    <p id="msg">Enter the prompt:</p>
    <input type="text" id="input" />
    <button onclick="accessOllama()">Access</button>
  </body>
  <script>
  const msg = document.getElementById('msg');
  const input = document.getElementById('input');
  const endpoint = 'http://localhost:11434/api/chat';
  const model = 'llama3.2';


async function accessOllama() {
  msg.textContent = 'wait...';
  const response = await fetch(endpoint, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      'model': model,
      'prompt': input.value,
      'stream': false
    })
  });
  const data = await response.json();
  console.log(data);
  msg.textContent = data.response;
}
  </script>
</html>


リスト4-31
<!DOCTYPE html>
<html>
  <head>
    <title>Ollama sample</title>
    <style>
    body {
        font-family: Arial, sans-serif;
        text-align: center;
      }
      p {
        margin: 25px 50px;
      }
      input {
        padding: 5px;
        margin-right: 5px;
        width: 300px;
      }
      button {
        padding: 5px 10px;
        background-color: #333;
        color: #fff;
      }
      ul {
        text-align: left;
        margin: 25px 50px;
      }
    </style>
  </head>
  <body>
    <h1>Ollama sample</h1>
    <p id="msg">Enter the prompt:</p>
    <input type="text" id="input" />
    <button onclick="accessOllama()">Access</button>
    <hr>
    <ul id="history"></ul>
  </body>
  <script>
  const msg = document.getElementById('msg');
  const input = document.getElementById('input');
  const hist = document.getElementById('history');
  const endpoint = 'http://localhost:11434/api/chat';
  const model = 'llama3.2';
  const messages = []; // メッセージ履歴


  // メッセージの追加処理
  function addMessage(message) {
    messages.push(message);
    const listItem = document.createElement('li');
    listItem.textContent = message.role + ':' + message.content;
    hist.prepend(listItem);
  }


  // Ollamaへのアクセス
  async function accessOllama() {
    const message = {
      'role':'user',
      'content': input.value
    }
    addMessage(message); // メッセージ追加
    msg.textContent = 'wait...';
    const response = await fetch(endpoint, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        'model': model,
        'messages': messages,
        'stream': false
      })
    });
    const data = await response.json();
    msg.textContent = data.message.content;
    addMessage(data.message); // メッセージ追加
    input.value = '';
  }
  </script>
</html>


リスト5-1
!pip install -q -U google-generativeai


リスト5-2
import google.generativeai as gemini
from google.colab import userdata


GEMINI_API_KEY = userdata.get('GEMINI_API_KEY')
gemini.configure(api_key=GEMINI_API_KEY)


リスト5-3
prompt = 'あなたは誰？' #@param {type:'string'}


model = gemini.GenerativeModel("gemini-1.5-flash")
response = model.generate_content(prompt)
print(response.text)


リスト5-4
import json
prompt = 'あなたは誰？' #@param {type:'string'}


generation_config = {
  "temperature": 1.0,
  "top_p": 0.7,
  "top_k": 64,
  "max_output_tokens": 1024,
}


model = gemini.GenerativeModel(
  model_name="gemini-1.5-flash",
  generation_config=generation_config,
)


response = model.generate_content(prompt)
print(response.text)


リスト5-5
model = gemini.GenerativeModel("gemini-1.5-flash")
chat = model.start_chat(
  history=[]
)


while True:
  prompt = input('user>>')
  if prompt == '':
    break
  response = chat.send_message(prompt)
  print('assistant>> ',response.text)


リスト5-6
import time
prompt = 'あなたは誰？' #@param {type:'string'}


model = gemini.GenerativeModel("gemini-1.5-pro")
response = model.generate_content(prompt, stream=True)
for chunk in response:
  print(chunk.text)
  time.sleep(0.2)


リスト5-7
!pip install wikipedia-api


リスト5-8
import wikipediaapi


# Wikipediaのインスタンスを作成 (日本語版)
wiki_wiki = wikipediaapi.Wikipedia(user_agent="Example/1.0", language='ja')


def get_wikipedia(title):
  print('***** get_wikipedia *****')
  # Wikipediaページを取得
  page = wiki_wiki.page(title)


  # ページが存在するか確認
  if page.exists():
    # ページの概要を返す
    return page.summary[0:500]
  else:
    # ページが存在しない場合
    return("※指定されたページは存在しません。")


リスト5-9
tools = [
  gemini.protos.Tool(
    function_declarations = [
      gemini.protos.FunctionDeclaration(
        name = "getWikipedia",
        description = "Wikipedia日本語版から指定したタイトルのコンテンツを取得する",
        parameters = gemini.protos.Schema(
          type = gemini.protos.Type.OBJECT,
          properties = {
            "title": gemini.protos.Schema(
              type = gemini.protos.Type.STRING,
            ),
          },
          required = ['title'],
        ),
      ),
    ],
  ),
]


リスト5-10
from google.ai.generativelanguage_v1beta.types import content


model = gemini.GenerativeModel(
  model_name="gemini-1.5-flash",
  tools=tools,
)


prompt = '' #@param {type:'string'}


response = model.generate_content(prompt)


for part in response.parts:
  if fn := part.function_call:
    if fn.name == 'getWikipedia':
      print(get_wikipedia(fn.args['title']))
  else:
    print(part.text)


リスト5-11
cd Desktop
mkdir gemini-app
cd gemini-app
npm init -y


リスト5-12
npm install @google/generative-ai


リスト5-13
GEMINI_API_KEY=《APIキー》


リスト5-14
require('dotenv').config();
const { GoogleGenerativeAI } = require("@google/generative-ai");
const { prompt } = require('./prompt.js');


const apiKey = process.env.GEMINI_API_KEY;
const genAI = new GoogleGenerativeAI(apiKey);


const model = genAI.getGenerativeModel({
  model: "gemini-1.5-flash",
});


async function main() {
  const query = await prompt("prompt: ");


  const response = await model.generateContent(query);
  console.log(response.response.text());
}


main();


リスト5-15
const model = genAI.getGenerativeModel({
  model: "gemini-1.5-flash",
  generationConfig: {
    maxOutputTokens: 1024,
    temperature: 1.0,
    topP: 0.95,
    topK: 30,
  },
});


リスト5-16
async function main() {
  const chat = model.startChat({
    history: [],
  });


  while (true) {
    const query = await prompt("prompt: ");
    if (query === "") {
      break;
    }
    const response = await chat.sendMessage(query);
    console.log('result: ',response.response.text());
  }
}


リスト5-17
function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}


async function main() {
  const query = await prompt("prompt: ");


  const response = await model.generateContentStream(query);


  for await (const chunk of response.stream) {
    process.stdout.write(chunk.text());
    await delay(200);
  }
}


リスト5-18
npm install wikijs


リスト5-19
require('dotenv').config();
const { GoogleGenerativeAI } = require("@google/generative-ai");
const { prompt } = require('./prompt.js');
const wiki = require('wikijs').default;


const apiKey = process.env.GEMINI_API_KEY;
const genAI = new GoogleGenerativeAI(apiKey);


// Wikipediaにアクセスする関数
async function getWikipedia(query) {
  console.log('***** getWikipedia *****');
  return wiki({ 
      apiUrl: 'https://ja.wikipedia.org/w/api.php'
    })
    .page(query)
    .then(page => page.summary())
    .catch(err => console.log(err));
}


リスト5-20
// ツール用関数定義
const tools = {
  functionDeclarations: [
    {
      name: "getWikipedia",
      description: "Wikipediaから指定したタイトルのコンテンツを取得する",
      parameters: {
        type: "OBJECT",
        properties: {
          title : {
            type: "STRING",
            description: "Wikipediaで検索するページのタイトル",
          }
        },
        required: ["title"],
      }
    }
  ]
}


リスト5-21
// ツールを使ったGenerativeModel作成
const model = genAI.getGenerativeModel({
  model: "gemini-1.5-flash",
  tools: tools,
});


リスト5-22
// メイン処理
async function main() {
  const query = await prompt("prompt: ");


  const response = await model.generateContent(query);
  const calls = response.response.functionCalls();


  if (calls) {
    const call = calls[0];
    if (call.name === "getWikipedia" && call.args.title) {
      const result = await getWikipedia(call.args.title);
      console.log(result);
    }
  } else {
    console.log(response.response.text());
  }
}


main();


リスト5-23
curl --header 'Content-Type: application/json' --data '{"contents":[{"parts":[{"text":"あなたは誰？"}]}]}' 'https://generativelanguage.googleapis.com/v1/models/gemini-1.5-flash:generateContent?key=《APIキー》'


リスト5-24
function myFunction () {
  const userProperties = PropertiesService.getUserProperties();
  userProperties.setProperty('GEMINI_API_KEY', '《APIキー》');
}


リスト5-25
// APIキーの準備
const userProperties = PropertiesService.getUserProperties();
const apiKey = userProperties.getProperty('GEMINI_API_KEY');


// エンドポイント
const URL = 'https://generativelanguage.googleapis.com/v1/models/gemini-1.5-flash:generateContent?key=' + apiKey;


// メイン関数
function myFunction () {
  const prompt = "あなたは誰？";  // ☆
  console.log(prompt);
  const result = access_gemini(prompt);
  console.log(result.candidates[0].content.parts[0].text);
}


// APIアクセス関数
function access_gemini(prompt) {
  var response = UrlFetchApp.fetch(URL, {
    method: "POST",
    headers: {
      "Content-Type": "application/json"
    },
    payload: JSON.stringify({
      "contents": [
        {
          "parts":  [
            { "text": prompt }
          ]
        }
      ]
    })
  });
  return JSON.parse(response.getContentText());
}


リスト5-26
await window.ai.canCreateTextSession();


リスト5-27
<!DOCTYPE html>
<html lang="ja">
<head>
  <title>Sample</title>
  <style>
  body {
    font-family: Arial, sans-serif;
    text-align: center;
  }
  p {
    margin: 25px 50px;
    text-align: left;
  }
  input {
    padding: 5px;
    margin-right: 5px;
    width: 300px;
  }
  button {
    padding: 5px 10px;
    background-color: #333;
    color: #fff;
  }
  ul {
    text-align: left;
    margin: 25px 50px;
  }
  </style>
</head>
<body>
  <h1>Sample</h1>
  <p id="msg">Please type prompt...</p>
  <input type="text" id="prompt" />
  <button onclick="load_ai()">Access AI</button>
</body>
<script>
const prompt = document.getElementById("prompt");
const msg = document.getElementById("msg");


async function load_ai() {
  const value = prompt.value;
  const session = await window.ai.createTextSession();
  const result = await session.prompt(value);
  msg.textContent = result;
}
</script>
</html>