Open Interpreter：ローカルPCでChatGPT×PC操作

[Dockerfile]
FROM ubuntu:22.04

RUN apt-get update && apt-get upgrade -y
RUN apt-get install -y git python3 python3-pip

RUN pip install open-interpreter==0.1.1
RUN pip install numpy matplotlib pandas

WORKDIR /root

[Terminal]
pip install open-interpreter

[Error]
You exceeded your current quota, please check your plan and billing details
The model `gpt-4` does not exist or you do not have access to it. Learn more: https://help.openai.com/en/articles/7102672-how-can-i-access-gpt-4.

[Error]
      *** CMake configuration failed
      [end of output]

  note: This error originates from a subprocess, and is likely not a problem with pip.
  ERROR: Failed building wheel for llama-cpp-python
Failed to build llama-cpp-python
ERROR: Could not build wheels for llama-cpp-python, which is required to install pyproject.toml-based projects
Error during installation with cuBLAS: Command

[Error]
      -- Looking for pthread.h
      -- Looking for pthread.h - not found
      -- Found Threads: TRUE
      -- Found CUDAToolkit: C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v11.1/include (found version "11.1.105")
      -- cuBLAS found
      CMake Error at C:/Program Files/CMake/share/cmake-3.21/Modules/CMakeDetermineCompilerId.cmake:497 (message):
        No CUDA toolset found.
      Call Stack (most recent call first):
        C:/Program Files/CMake/share/cmake-3.21/Modules/CMakeDetermineCompilerId.cmake:6 (CMAKE_DETERMINE_COMPILER_ID_BUILD)
        C:/Program Files/CMake/share/cmake-3.21/Modules/CMakeDetermineCompilerId.cmake:59 (__determine_compiler_id_test)
        C:/Program Files/CMake/share/cmake-3.21/Modules/CMakeDetermineCUDACompiler.cmake:283 (CMAKE_DETERMINE_COMPILER_ID)
        vendor/llama.cpp/CMakeLists.txt:286 (enable_language)

[Error]
ModuleNotFoundError: No module named 'llama_cpp'

▌ Failed to install TheBloke/CodeLlama-34B-Instruct-GGUF.

Common Fixes: You can follow our simple setup docs at the link below to resolve
common errors.


 https://github.com/KillianLucas/open-interpreter/tree/main/docs

If you've tried that and you're still getting an error, we have likely not built
the proper TheBloke/CodeLlama-34B-Instruct-GGUF support for your system.

( Running language models locally is a difficult task! If you have insight into
the best way to implement this across platforms/architectures, please join the
Open Interpreter community Discord and consider contributing the project's
development. )

Press enter to switch to GPT-4 (recommended).

[Anaconda Prompt]
conda create -n openinterpreter python=3.11
activate openinterpreter 
conda info -e

[Terminal]
pip install open-interpreter

[Terminal]
interpreter -y

[Prompt]
make inter dir here

[OUT]
Let's create a new directory called "inter" here.

mkdir inter

  Microsoft Windows [Version 10.0.22000.1455]
  (c) Microsoft Corporation. All rights reserved.
  (openinterpreter) C:\Users\KIYO-\Desktop\temp>mkdir inter
  (openinterpreter) C:\Users\KIYO-\Desktop\temp>

  it appears that the "inter" directory was created
  successfully.

  Now, let's move into this new directory and list its
  contents using the ls command.

cd inter
ls

  (openinterpreter) C:\Users\KIYO-\Desktop\temp>cd inter
  'ls' は、内部コマンドまたは外部コマンド、
  (openinterpreter) C:\Users\KIYO-\Desktop\temp\inter>ls
  ファイルとして認識されていません。
  (openinterpreter) C:\Users\KIYO-\Desktop\temp\inter>


  it appears that the ls command was not recognized as an
  internal or external command. This is likely because the
  ls command is a Unix-specific command and may not be
  available on Windows systems.

  To list the contents of the "inter" directory, we can use
  the dir command instead. Here's what that looks like:

dir

[Prompt]
where is the main town in Japan?

[OUT]
  The main town in Japan is Tokyo. It is the capital of
  Honshu, the largest island of Japan, and is located in the
  Kanto region. The city has a population of over 7 million
  people and is known for its vibrant culture, rich history,
  and modern infrastructure. Some popular attractions in
  Tokyo include the Tokyo Tower, the Meiji Shrine, and the
  Tsukiji Fish Market.

  Now, let's move on to your next task. What would you like
  to do next?

[cli.pyの一部]
  # Setup CLI
  parser = argparse.ArgumentParser(description='Chat with Open Interpreter.')
  
  parser.add_argument('-y',
                      '--yes',
                      action='store_true',
                      default=AUTO_RUN,
                      help='execute code without user confirmation')
  parser.add_argument('-f',
                      '--fast',
                      action='store_true',
                      default=FAST_MODE,
                      help='use gpt-3.5-turbo instead of gpt-4')
  parser.add_argument('-l',
                      '--local',
                      action='store_true',
                      default=LOCAL_RUN,
                      help='run fully local with code-llama')
  parser.add_argument(
                      '--falcon',
                      action='store_true',
                      default=False,
                      help='run fully local with falcon-40b')
  parser.add_argument('-d',
                      '--debug',
                      action='store_true',
                      default=DEBUG,
                      help='prints extra information')
  
  parser.add_argument('--model',
                      type=str,
                      help='model name (for OpenAI compatible APIs) or HuggingFace repo',
                      default="",
                      required=False)
  
  parser.add_argument('--max_tokens',
                      type=int,
                      help='max tokens generated (for locally run models)')
  parser.add_argument('--context_window',
                      type=int,
                      help='context window in tokens (for locally run models)')
  
  parser.add_argument('--api_base',
                      type=str,
                      help='change your api_base to any OpenAI compatible api',
                      default="",
                      required=False)
  
  parser.add_argument('--use-azure',
                      action='store_true',
                      default=USE_AZURE,
                      help='use Azure OpenAI Services')
  
  parser.add_argument('--version',
                      action='store_true',
                      help='display current Open Interpreter version')

  args = parser.parse_args()

[Terminal]
interpreter --yes

[Terminal]
interpreter --local

[Terminal]
interpreter --version

[Terminal]
interpreter --fast

[Terminal]
interpreter --local

[Terminal]
interpreter --model tiiuae/falcon-180B

[Terminal]
interpreter --debug

[Chatの途中で設定変更]
> %debug true <- Turns on debug mode

> %debug false <- Turns off debug mode

[Terminal]
interpreter --use-azure

[IN]
!pip install open-interpreter
# Google Colab users: restart your runtime here.

import interpreter

# Paste your OpenAI API key below.
interpreter.api_key = "your_openai_api_key"

interpreter.auto_run = True

interpreter.chat("Please print hello world.")

[OUT]
-

[IN]
interpreter.model = "gpt-3.5-turbo" #GPT -3.5を選択

[interpreter/interpreter.py]
class Interpreter:

  def __init__(self):
    self.messages = []
    self.temperature = 0.001
    self.api_key = None
    self.auto_run = False
    self.local = False
    self.model = "gpt-4"
    self.debug_mode = False
    self.api_base = None # Will set it to whatever OpenAI wants
    self.context_window = 2000 # For local models only
    self.max_tokens = 750 # For local models only
    # Azure OpenAI
    self.use_azure = False
    self.azure_api_base = None
    self.azure_api_version = None
    self.azure_deployment_name = None
    self.azure_api_type = "azure"

    # Get default system message
    here = os.path.abspath(os.path.dirname(__file__))
    with open(os.path.join(here, 'system_message.txt'), 'r') as f:
      self.system_message = f.read().strip()

    # Store Code Interpreter instances for each language
    self.code_interpreters = {}

    # No active block to start
    # (blocks are visual representation of messages on the terminal)
    self.active_block = None

    # Note: While Open Interpreter can use Llama, we will prioritize gpt-4.
    # gpt-4 is faster, smarter, can call functions, and is all-around easier to use.
    # This makes gpt-4 better aligned with Open Interpreters priority to be easy to use.
    self.llama_instance = None

[IN]
interpreter.chat(<聞きたいこと／やってほしいことのPrompt>)

[IN]
interpreter.reset()

[IN]
messages = interpreter.chat("My name is Killian.", return_messages=True) # Save messages to 'messages'
interpreter.reset() # Reset interpreter ("Killian" will be forgotten)

interpreter.load(messages) # Resume chat from 'messages' ("Killian" will be remembered)

[IN]
interpreter.model = "gpt-3.5-turbo"