create duck db

open-interpreter/.devcontainer/DockerFile

@@ -0,0 +1 @@
+FROM python:3.11

open-interpreter/.devcontainer/devcontainer.json

@@ -0,0 +1,10 @@
+{
+	"name": "Open Interpreter",
+	"dockerFile": "DockerFile",
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	// "features": {},
+	"onCreateCommand": "pip install .",
+	"postAttachCommand": "interpreter -y"
+	// Configure tool-specific properties.
+	// "customizations": {},
+}

open-interpreter/.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,71 @@
+name: Bug report
+description: Create a report to help us improve
+labels:
+  - bug
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Your issue may have already been reported. Please check the following link for common issues and solutions.
+
+        [Commonly faced issues and their solutions](https://github.com/KillianLucas/open-interpreter/issues/164)
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the bug
+      description: A clear and concise description of what the bug is.
+    validations:
+      required: true
+  - type: textarea
+    id: repro
+    attributes:
+      label: Reproduce
+      description: Steps to reproduce the behavior
+      placeholder: |
+        1. Go to '...'
+        2. Click on '....'
+        3. Scroll down to '....'
+        4. See error
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+      description: A clear and concise description of what you expected to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots
+      description: If applicable, add screenshots to help explain your problem.
+  - type: input
+    id: oiversion
+    attributes:
+      label: Open Interpreter version
+      description: Run `pip show open-interpreter`
+      placeholder: e.g. 0.1.1
+    validations:
+      required: true
+  - type: input
+    id: pythonversion
+    attributes:
+      label: Python version
+      description: Run `python -V`
+      placeholder: e.g. 3.11.5
+    validations:
+      required: true
+  - type: input
+    id: osversion
+    attributes:
+      label: Operating System name and version
+      description: The name and version of your OS.
+      placeholder: e.g. Windows 11 / macOS 13 / Ubuntu 22.10
+    validations:
+      required: true
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional context
+      description: Add any other context about the problem here.

open-interpreter/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

open-interpreter/.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,27 @@
+name: Feature request
+description: Suggest an idea for this project
+labels:
+  - enhancement
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: Is your feature request related to a problem? Please describe.
+      description: A clear and concise description of what the problem is.
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the solution you'd like
+      description: A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Describe alternatives you've considered
+      description: A clear and concise description of any alternative solutions or features you've considered.
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional context
+      description: Add any other context about the problem here.

open-interpreter/.github/pull_request_template.md

@@ -0,0 +1,15 @@
+### Describe the changes you have made:
+
+### Reference any relevant issues (e.g. "Fixes #000"):
+
+### Pre-Submission Checklist (optional but appreciated):
+
+- [ ] I have included relevant documentation updates (stored in /docs)
+- [ ] I have read `docs/CONTRIBUTING.md`
+- [ ] I have read `docs/ROADMAP.md`
+
+### OS Tests (optional but appreciated):
+
+- [ ] Tested on Windows
+- [ ] Tested on MacOS
+- [ ] Tested on Linux

open-interpreter/.github/workflows/potential-duplicates.yml

@@ -0,0 +1,31 @@
+name: Potential Duplicates
+on:
+  issues:
+    types: [opened, edited]
+jobs:
+  run:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: wow-actions/potential-duplicates@v1
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          # Issue title filter work with anymatch https://www.npmjs.com/package/anymatch.
+          # Any matched issue will stop detection immediately.
+          # You can specify multi filters in each line.
+          filter: ''
+          # Exclude keywords in title before detecting.
+          exclude: ''
+          # Label to set, when potential duplicates are detected.
+          label: potential-duplicate
+          # Get issues with state to compare. Supported state: 'all', 'closed', 'open'.
+          state: all
+          # If similarity is higher than this threshold([0,1]), issue will be marked as duplicate.
+          threshold: 0.6
+          # Reactions to be add to comment when potential duplicates are detected.
+          # Available reactions: "-1", "+1", "confused", "laugh", "heart", "hooray", "rocket", "eyes"
+          reactions: 'eyes, confused'
+          # Comment to post when potential duplicates are detected.
+          comment: >
+            Potential duplicates: {{#issues}}
+              - [#{{ number }}] {{ title }} ({{ accuracy }}%)
+            {{/issues}}

open-interpreter/.github/workflows/python-package.yml

@@ -0,0 +1,37 @@
+name: Build and Test
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: true
+      matrix:
+        python-version: ["3.10", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v3
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install poetry
+        run: |
+          curl -sSL https://install.python-poetry.org | python3 -
+      - name: Install dependencies
+        run: |
+          # Update poetry to the latest version.
+          poetry self update
+          # Ensure dependencies are installed without relying on a lock file.
+          poetry update
+          poetry install
+      - name: Test with pytest
+        run: |
+          poetry run pytest -s -x
+        env:
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}

open-interpreter/.gitignore

@@ -0,0 +1,237 @@
+llama.log
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+!.vscode/*.code-snippets
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+# Ignore the .replit configuration file
+.replit
+
+# Ignore Nix directories
+nix/
+
+# Ignore the replit.nix configuration file
+replit.nix
+
+# Ignore misc directory
+misc/
+
+# Ignore litellm_uuid.txt
+litellm_uuid.txt

open-interpreter/.pre-commit-config.yaml

@@ -0,0 +1,15 @@
+repos:
+  # Using this mirror lets us use mypyc-compiled black, which is 2x faster
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: 23.10.1
+    hooks:
+      - id: black
+        # It is recommended to specify the latest version of Python
+        # supported by your project here, or alternatively use
+        # pre-commit's default_language_version, see
+        # https://pre-commit.com/#top_level-default_language_version
+        language_version: python3.11
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort

open-interpreter/LICENSE

@@ -0,0 +1,660 @@
+GNU AFFERO GENERAL PUBLIC LICENSE
+Version 3, 19 November 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+        Preamble
+
+The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate. Many developers of free software are heartened and
+encouraged by the resulting cooperation. However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community. It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server. Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals. This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+The precise terms and conditions for copying, distribution and
+modification follow.
+
+TERMS AND CONDITIONS
+
+0. Definitions.
+
+"This License" refers to version 3 of the GNU Affero General Public License.
+
+"Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+"The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+1. Source Code.
+
+The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+The Corresponding Source for a work in source code form is that
+same work.
+
+2. Basic Permissions.
+
+All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+4. Conveying Verbatim Copies.
+
+You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+5. Conveying Modified Source Versions.
+
+You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+a) The work must carry prominent notices stating that you modified
+it, and giving a relevant date.
+
+b) The work must carry prominent notices stating that it is
+released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to
+"keep intact all notices".
+
+c) You must license the entire work, as a whole, under this
+License to anyone who comes into possession of a copy. This
+License will therefore apply, along with any applicable section 7
+additional terms, to the whole of the work, and all its parts,
+regardless of how they are packaged. This License gives no
+permission to license the work in any other way, but it does not
+invalidate such permission if you have separately received it.
+
+d) If the work has interactive user interfaces, each must display
+Appropriate Legal Notices; however, if the Program has interactive
+interfaces that do not display Appropriate Legal Notices, your
+work need not make them do so.
+
+A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+6. Conveying Non-Source Forms.
+
+You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+a) Convey the object code in, or embodied in, a physical product
+(including a physical distribution medium), accompanied by the
+Corresponding Source fixed on a durable physical medium
+customarily used for software interchange.
+
+b) Convey the object code in, or embodied in, a physical product
+(including a physical distribution medium), accompanied by a
+written offer, valid for at least three years and valid for as
+long as you offer spare parts or customer support for that product
+model, to give anyone who possesses the object code either (1) a
+copy of the Corresponding Source for all the software in the
+product that is covered by this License, on a durable physical
+medium customarily used for software interchange, for a price no
+more than your reasonable cost of physically performing this
+conveying of source, or (2) access to copy the
+Corresponding Source from a network server at no charge.
+
+c) Convey individual copies of the object code with a copy of the
+written offer to provide the Corresponding Source. This
+alternative is allowed only occasionally and noncommercially, and
+only if you received the object code with such an offer, in accord
+with subsection 6b.
+
+d) Convey the object code by offering access from a designated
+place (gratis or for a charge), and offer equivalent access to the
+Corresponding Source in the same way through the same place at no
+further charge. You need not require recipients to copy the
+Corresponding Source along with the object code. If the place to
+copy the object code is a network server, the Corresponding Source
+may be on a different server (operated by you or a third party)
+that supports equivalent copying facilities, provided you maintain
+clear directions next to the object code saying where to find the
+Corresponding Source. Regardless of what server hosts the
+Corresponding Source, you remain obligated to ensure that it is
+available for as long as needed to satisfy these requirements.
+
+e) Convey the object code using peer-to-peer transmission, provided
+you inform other peers where the object code and Corresponding
+Source of the work are being offered to the general public at no
+charge under subsection 6d.
+
+A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+"Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+7. Additional Terms.
+
+"Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+a) Disclaiming warranty or limiting liability differently from the
+terms of sections 15 and 16 of this License; or
+
+b) Requiring preservation of specified reasonable legal notices or
+author attributions in that material or in the Appropriate Legal
+Notices displayed by works containing it; or
+
+c) Prohibiting misrepresentation of the origin of that material, or
+requiring that modified versions of such material be marked in
+reasonable ways as different from the original version; or
+
+d) Limiting the use for publicity purposes of names of licensors or
+authors of the material; or
+
+e) Declining to grant rights under trademark law for use of some
+trade names, trademarks, or service marks; or
+
+f) Requiring indemnification of licensors and authors of that
+material by anyone who conveys the material (or modified versions of
+it) with contractual assumptions of liability to the recipient, for
+any liability that these contractual assumptions directly impose on
+those licensors and authors.
+
+All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+8. Termination.
+
+You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+9. Acceptance Not Required for Having Copies.
+
+You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+10. Automatic Licensing of Downstream Recipients.
+
+Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+11. Patents.
+
+A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+12. No Surrender of Others' Freedom.
+
+If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+13. Remote Network Interaction; Use with the GNU General Public License.
+
+Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software. This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+14. Revised Versions of this License.
+
+The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time. Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+15. Disclaimer of Warranty.
+
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+16. Limitation of Liability.
+
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+17. Interpretation of Sections 15 and 16.
+
+If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+END OF TERMS AND CONDITIONS
+
+How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+<one line to give the program's name and a brief idea of what it does.>
+Copyright (C) <year> <name of author>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source. For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code. There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<http://www.gnu.org/licenses/>.

open-interpreter/README.md

@@ -0,0 +1,413 @@
+<h1 align="center">● Open Interpreter</h1>
+
+<p align="center">
+    <a href="https://discord.gg/Hvz9Axh84z">
+        <img alt="Discord" src="https://img.shields.io/discord/1146610656779440188?logo=discord&style=flat&logoColor=white"/></a>
+    <a href="https://github.com/OpenInterpreter/open-interpreter/blob/main/docs/README_JA.md"><img src="https://img.shields.io/badge/ドキュメント-日本語-white.svg" alt="JA doc"/></a>
+    <a href="https://github.com/OpenInterpreter/open-interpreter/blob/main/docs/README_ZH.md"><img src="https://img.shields.io/badge/文档-中文版-white.svg" alt="ZH doc"/></a>
+    <a href="https://github.com/OpenInterpreter/open-interpreter/blob/main/docs/README_ES.md"> <img src="https://img.shields.io/badge/Español-white.svg" alt="ES doc"/></a>
+    <a href="https://github.com/OpenInterpreter/open-interpreter/blob/main/docs/README_IN.md"><img src="https://img.shields.io/badge/Hindi-white.svg" alt="IN doc"/></a>
+    <a href="https://github.com/OpenInterpreter/open-interpreter/blob/main/LICENSE"><img src="https://img.shields.io/static/v1?label=license&message=AGPL&color=white&style=flat" alt="License"/></a>
+    <br>
+    <br>
+    <br><a href="https://0ggfznkwh4j.typeform.com/to/G21i9lJ2">Get early access to the desktop app</a>‎ ‎ |‎ ‎ <a href="https://docs.openinterpreter.com/">Documentation</a><br>
+</p>
+
+<br>
+
+![poster](https://github.com/KillianLucas/open-interpreter/assets/63927363/08f0d493-956b-4d49-982e-67d4b20c4b56)
+
+<br>
+<p align="center">
+<strong>The New Computer Update</strong> introduced <strong><code>--os</code></strong> and a new <strong>Computer API</strong>. <a href="https://changes.openinterpreter.com/log/the-new-computer-update">Read On →</a>
+</p>
+<br>
+
+```shell
+pip install open-interpreter
+```
+
+> Not working? Read our [setup guide](https://docs.openinterpreter.com/getting-started/setup).
+
+```shell
+interpreter
+```
+
+<br>
+
+**Open Interpreter** lets LLMs run code (Python, Javascript, Shell, and more) locally. You can chat with Open Interpreter through a ChatGPT-like interface in your terminal by running `$ interpreter` after installing.
+
+This provides a natural-language interface to your computer's general-purpose capabilities:
+
+- Create and edit photos, videos, PDFs, etc.
+- Control a Chrome browser to perform research
+- Plot, clean, and analyze large datasets
+- ...etc.
+
+**⚠️ Note: You'll be asked to approve code before it's run.**
+
+<br>
+
+## Demo
+
+https://github.com/KillianLucas/open-interpreter/assets/63927363/37152071-680d-4423-9af3-64836a6f7b60
+
+#### An interactive demo is also available on Google Colab:
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1WKmRXZgsErej2xUriKzxrEAXdxMSgWbb?usp=sharing)
+
+#### Along with an example voice interface, inspired by _Her_:
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1NojYGHDgxH6Y1G1oxThEBBb2AtyODBIK)
+
+## Quick Start
+
+```shell
+pip install open-interpreter
+```
+
+### Terminal
+
+After installation, simply run `interpreter`:
+
+```shell
+interpreter
+```
+
+### Python
+
+```python
+from interpreter import interpreter
+
+interpreter.chat("Plot AAPL and META's normalized stock prices") # Executes a single command
+interpreter.chat() # Starts an interactive chat
+```
+
+### GitHub Codespaces
+
+Press the `,` key on this repository's GitHub page to create a codespace. After a moment, you'll receive a cloud virtual machine environment pre-installed with open-interpreter. You can then start interacting with it directly and freely confirm its execution of system commands without worrying about damaging the system.
+
+## Comparison to ChatGPT's Code Interpreter
+
+OpenAI's release of [Code Interpreter](https://openai.com/blog/chatgpt-plugins#code-interpreter) with GPT-4 presents a fantastic opportunity to accomplish real-world tasks with ChatGPT.
+
+However, OpenAI's service is hosted, closed-source, and heavily restricted:
+
+- No internet access.
+- [Limited set of pre-installed packages](https://wfhbrian.com/mastering-chatgpts-code-interpreter-list-of-python-packages/).
+- 100 MB maximum upload, 120.0 second runtime limit.
+- State is cleared (along with any generated files or links) when the environment dies.
+
+---
+
+Open Interpreter overcomes these limitations by running in your local environment. It has full access to the internet, isn't restricted by time or file size, and can utilize any package or library.
+
+This combines the power of GPT-4's Code Interpreter with the flexibility of your local development environment.
+
+## Commands
+
+**Update:** The Generator Update (0.1.5) introduced streaming:
+
+```python
+message = "What operating system are we on?"
+
+for chunk in interpreter.chat(message, display=False, stream=True):
+  print(chunk)
+```
+
+### Interactive Chat
+
+To start an interactive chat in your terminal, either run `interpreter` from the command line:
+
+```shell
+interpreter
+```
+
+Or `interpreter.chat()` from a .py file:
+
+```python
+interpreter.chat()
+```
+
+**You can also stream each chunk:**
+
+```python
+message = "What operating system are we on?"
+
+for chunk in interpreter.chat(message, display=False, stream=True):
+  print(chunk)
+```
+
+### Programmatic Chat
+
+For more precise control, you can pass messages directly to `.chat(message)`:
+
+```python
+interpreter.chat("Add subtitles to all videos in /videos.")
+
+# ... Streams output to your terminal, completes task ...
+
+interpreter.chat("These look great but can you make the subtitles bigger?")
+
+# ...
+```
+
+### Start a New Chat
+
+In Python, Open Interpreter remembers conversation history. If you want to start fresh, you can reset it:
+
+```python
+interpreter.messages = []
+```
+
+### Save and Restore Chats
+
+`interpreter.chat()` returns a List of messages, which can be used to resume a conversation with `interpreter.messages = messages`:
+
+```python
+messages = interpreter.chat("My name is Killian.") # Save messages to 'messages'
+interpreter.messages = [] # Reset interpreter ("Killian" will be forgotten)
+
+interpreter.messages = messages # Resume chat from 'messages' ("Killian" will be remembered)
+```
+
+### Customize System Message
+
+You can inspect and configure Open Interpreter's system message to extend its functionality, modify permissions, or give it more context.
+
+```python
+interpreter.system_message += """
+Run shell commands with -y so the user doesn't have to confirm them.
+"""
+print(interpreter.system_message)
+```
+
+### Change your Language Model
+
+Open Interpreter uses [LiteLLM](https://docs.litellm.ai/docs/providers/) to connect to hosted language models.
+
+You can change the model by setting the model parameter:
+
+```shell
+interpreter --model gpt-3.5-turbo
+interpreter --model claude-2
+interpreter --model command-nightly
+```
+
+In Python, set the model on the object:
+
+```python
+interpreter.llm.model = "gpt-3.5-turbo"
+```
+
+[Find the appropriate "model" string for your language model here.](https://docs.litellm.ai/docs/providers/)
+
+### Running Open Interpreter locally
+
+#### Terminal
+
+Open Interpreter can use OpenAI-compatible server to run models locally. (LM Studio, jan.ai, ollama etc)
+
+Simply run `interpreter` with the api_base URL of your inference server (for LM studio it is `http://localhost:1234/v1` by default):
+
+```shell
+interpreter --api_base "http://localhost:1234/v1" --api_key "fake_key"
+```
+
+Alternatively you can use Llamafile without installing any third party software just by running
+
+```shell
+interpreter --local
+```
+
+for a more detailed guide check out [this video by Mike Bird](https://www.youtube.com/watch?v=CEs51hGWuGU?si=cN7f6QhfT4edfG5H)
+
+**How to run LM Studio in the background.**
+
+1. Download [https://lmstudio.ai/](https://lmstudio.ai/) then start it.
+2. Select a model then click **↓ Download**.
+3. Click the **↔️** button on the left (below 💬).
+4. Select your model at the top, then click **Start Server**.
+
+Once the server is running, you can begin your conversation with Open Interpreter.
+
+> **Note:** Local mode sets your `context_window` to 3000, and your `max_tokens` to 1000. If your model has different requirements, set these parameters manually (see below).
+
+#### Python
+
+Our Python package gives you more control over each setting. To replicate and connect to LM Studio, use these settings:
+
+```python
+from interpreter import interpreter
+
+interpreter.offline = True # Disables online features like Open Procedures
+interpreter.llm.model = "openai/x" # Tells OI to send messages in OpenAI's format
+interpreter.llm.api_key = "fake_key" # LiteLLM, which we use to talk to LM Studio, requires this
+interpreter.llm.api_base = "http://localhost:1234/v1" # Point this at any OpenAI compatible server
+
+interpreter.chat()
+```
+
+#### Context Window, Max Tokens
+
+You can modify the `max_tokens` and `context_window` (in tokens) of locally running models.
+
+For local mode, smaller context windows will use less RAM, so we recommend trying a much shorter window (~1000) if it's failing / if it's slow. Make sure `max_tokens` is less than `context_window`.
+
+```shell
+interpreter --local --max_tokens 1000 --context_window 3000
+```
+
+### Verbose mode
+
+To help you inspect Open Interpreter we have a `--verbose` mode for debugging.
+
+You can activate verbose mode by using its flag (`interpreter --verbose`), or mid-chat:
+
+```shell
+$ interpreter
+...
+> %verbose true <- Turns on verbose mode
+
+> %verbose false <- Turns off verbose mode
+```
+
+### Interactive Mode Commands
+
+In the interactive mode, you can use the below commands to enhance your experience. Here's a list of available commands:
+
+**Available Commands:**
+
+- `%verbose [true/false]`: Toggle verbose mode. Without arguments or with `true` it
+  enters verbose mode. With `false` it exits verbose mode.
+- `%reset`: Resets the current session's conversation.
+- `%undo`: Removes the previous user message and the AI's response from the message history.
+- `%tokens [prompt]`: (_Experimental_) Calculate the tokens that will be sent with the next prompt as context and estimate their cost. Optionally calculate the tokens and estimated cost of a `prompt` if one is provided. Relies on [LiteLLM's `cost_per_token()` method](https://docs.litellm.ai/docs/completion/token_usage#2-cost_per_token) for estimated costs.
+- `%help`: Show the help message.
+
+### Configuration / Profiles
+
+Open Interpreter allows you to set default behaviors using `yaml` files.
+
+This provides a flexible way to configure the interpreter without changing command-line arguments every time.
+
+Run the following command to open the profiles directory:
+
+```
+interpreter --profiles
+```
+
+You can add `yaml` files there. The default profile is named `default.yaml`.
+
+#### Multiple Profiles
+
+Open Interpreter supports multiple `yaml` files, allowing you to easily switch between configurations:
+
+```
+interpreter --profile my_profile.yaml
+```
+
+## Sample FastAPI Server
+
+The generator update enables Open Interpreter to be controlled via HTTP REST endpoints:
+
+```python
+# server.py
+
+from fastapi import FastAPI
+from fastapi.responses import StreamingResponse
+from interpreter import interpreter
+
+app = FastAPI()
+
+@app.get("/chat")
+def chat_endpoint(message: str):
+    def event_stream():
+        for result in interpreter.chat(message, stream=True):
+            yield f"data: {result}\n\n"
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+@app.get("/history")
+def history_endpoint():
+    return interpreter.messages
+```
+
+```shell
+pip install fastapi uvicorn
+uvicorn server:app --reload
+```
+
+You can also start a server identical to the one above by simply running `interpreter.server()`.
+
+## Android
+
+The step-by-step guide for installing Open Interpreter on your Android device can be found in the [open-interpreter-termux repo](https://github.com/MikeBirdTech/open-interpreter-termux).
+
+## Safety Notice
+
+Since generated code is executed in your local environment, it can interact with your files and system settings, potentially leading to unexpected outcomes like data loss or security risks.
+
+**⚠️ Open Interpreter will ask for user confirmation before executing code.**
+
+You can run `interpreter -y` or set `interpreter.auto_run = True` to bypass this confirmation, in which case:
+
+- Be cautious when requesting commands that modify files or system settings.
+- Watch Open Interpreter like a self-driving car, and be prepared to end the process by closing your terminal.
+- Consider running Open Interpreter in a restricted environment like Google Colab or Replit. These environments are more isolated, reducing the risks of executing arbitrary code.
+
+There is **experimental** support for a [safe mode](https://github.com/OpenInterpreter/open-interpreter/blob/main/docs/SAFE_MODE.md) to help mitigate some risks.
+
+## How Does it Work?
+
+Open Interpreter equips a [function-calling language model](https://platform.openai.com/docs/guides/gpt/function-calling) with an `exec()` function, which accepts a `language` (like "Python" or "JavaScript") and `code` to run.
+
+We then stream the model's messages, code, and your system's outputs to the terminal as Markdown.
+
+# Access Documentation Offline
+
+The full [documentation](https://docs.openinterpreter.com/) is accessible on-the-go without the need for an internet connection.
+
+[Node](https://nodejs.org/en) is a pre-requisite:
+
+- Version 18.17.0 or any later 18.x.x version.
+- Version 20.3.0 or any later 20.x.x version.
+- Any version starting from 21.0.0 onwards, with no upper limit specified.
+
+Install [Mintlify](https://mintlify.com/):
+
+```bash
+npm i -g mintlify@latest
+```
+
+Change into the docs directory and run the appropriate command:
+
+```bash
+# Assuming you're at the project's root directory
+cd ./docs
+
+# Run the documentation server
+mintlify dev
+```
+
+A new browser window should open. The documentation will be available at [http://localhost:3000](http://localhost:3000) as long as the documentation server is running.
+
+# Contributing
+
+Thank you for your interest in contributing! We welcome involvement from the community.
+
+Please see our [contributing guidelines](https://github.com/OpenInterpreter/open-interpreter/blob/main/docs/CONTRIBUTING.md) for more details on how to get involved.
+
+# Roadmap
+
+Visit [our roadmap](https://github.com/KillianLucas/open-interpreter/blob/main/docs/ROADMAP.md) to preview the future of Open Interpreter.
+
+**Note**: This software is not affiliated with OpenAI.
+
+![thumbnail-ncu](https://github.com/KillianLucas/open-interpreter/assets/63927363/1b19a5db-b486-41fd-a7a1-fe2028031686)
+
+> Having access to a junior programmer working at the speed of your fingertips ... can make new workflows effortless and efficient, as well as open the benefits of programming to new audiences.
+>
+> — _OpenAI's Code Interpreter Release_
+
+<br>

open-interpreter/docs/CONTRIBUTING.md

@@ -0,0 +1,91 @@
+# ●
+
+**Open Interpreter is large, open-source initiative to build a standard interface between language models and computers.**
+
+There are many ways to contribute, from helping others on [Github](https://github.com/KillianLucas/open-interpreter/issues) or [Discord](https://discord.gg/6p3fD6rBVm), writing documentation, or improving code.
+
+We depend on contributors like you. Let's build this.
+
+## What should I work on?
+
+First, please familiarize yourself with our [project scope](https://github.com/KillianLucas/open-interpreter/blob/main/docs/ROADMAP.md#whats-in-our-scope). Then, pick up a task from our [roadmap](https://github.com/KillianLucas/open-interpreter/blob/main/docs/ROADMAP.md) or work on solving an [issue](https://github.com/KillianLucas/open-interpreter/issues).
+
+If you encounter a bug or have a feature in mind, don't hesitate to [open a new issue](https://github.com/KillianLucas/open-interpreter/issues/new/choose).
+
+## Philosophy
+
+This is a minimalist, **tightly scoped** project that places a premium on simplicity. We're skeptical of new extensions, integrations, and extra features. We would rather not extend the system if it adds nonessential complexity.
+
+# Contribution Guidelines
+
+1. Before taking on significant code changes, please discuss your ideas on [Discord](https://discord.gg/6p3fD6rBVm) to ensure they align with our vision. We want to keep the codebase simple and unintimidating for new users.
+2. Fork the repository and create a new branch for your work.
+3. Follow the [Running Your Local Fork](https://github.com/KillianLucas/open-interpreter/blob/main/docs/CONTRIBUTING.md#running-your-local-fork) guide below.
+4. Make changes with clear code comments explaining your approach. Try to follow existing conventions in the code.
+5. Follow the [Code Formatting and Linting](https://github.com/KillianLucas/open-interpreter/blob/main/docs/CONTRIBUTING.md#code-formatting-and-linting) guide below.
+6. Open a PR into `main` linking any related issues. Provide detailed context on your changes.
+
+We will review PRs when possible and work with you to integrate your contribution. Please be patient as reviews take time. Once approved, your code will be merged.
+
+## Running Your Local Fork
+
+**Note: for anyone testing the new `--local`, `--os`, and `--local --os` modes: When you run `poetry install` you aren't installing the optional dependencies and it'll throw errors. To test `--local` mode, run `poetry install -E local`. To test `--os` mode, run `poetry install -E os`. To test `--local --os` mode, run `poetry install -E local -E os`. You can edit the system messages for these modes in `interpreter/terminal_interface/profiles/defaults`.**
+
+Once you've forked the code and created a new branch for your work, you can run the fork in CLI mode by following these steps:
+
+1. CD into the project folder by running `cd open-interpreter`.
+2. Install `poetry` [according to their documentation](https://python-poetry.org/docs/#installing-with-pipx), which will create a virtual environment for development + handle dependencies.
+3. Install dependencies by running `poetry install`.
+4. Run the program with `poetry run interpreter`. Run tests with `poetry run pytest -s -x`.
+
+**Note**: This project uses [`black`](https://black.readthedocs.io/en/stable/index.html) and [`isort`](https://pypi.org/project/isort/) via a [`pre-commit`](https://pre-commit.com/) hook to ensure consistent code style. If you need to bypass it for some reason, you can `git commit` with the `--no-verify` flag.
+
+### Installing New Dependencies
+
+If you wish to install new dependencies into the project, please use `poetry add package-name`.
+
+### Installing Developer Dependencies
+
+If you need to install dependencies specific to development, like testing tools, formatting tools, etc. please use `poetry add package-name --group dev`.
+
+### Known Issues
+
+For some, `poetry install` might hang on some dependencies. As a first step, try to run the following command in your terminal:
+
+`export PYTHON_KEYRING_BACKEND=keyring.backends.fail.Keyring`
+
+Then run `poetry install` again. If this doesn't work, please join our [Discord community](https://discord.gg/6p3fD6rBVm) for help.
+
+## Code Formatting and Linting
+
+Our project uses `black` for code formatting and `isort` for import sorting. To ensure consistency across contributions, please adhere to the following guidelines:
+
+1. **Install Pre-commit Hooks**:
+
+   If you want to automatically format your code every time you make a commit, install the pre-commit hooks.
+
+   ```bash
+   pip install pre-commit
+   pre-commit install
+   ```
+
+   After installing, the hooks will automatically check and format your code every time you commit.
+
+2. **Manual Formatting**:
+
+   If you choose not to use the pre-commit hooks, you can manually format your code using:
+
+   ```bash
+   black .
+   isort .
+   ```
+
+# Licensing
+
+Contributions to Open Interpreter would be under the MIT license before version 0.2.0, or under AGPL for subsequent contributions.
+
+# Questions?
+
+Join our [Discord community](https://discord.gg/6p3fD6rBVm) and post in the #General channel to connect with contributors. We're happy to guide you through your first open source contribution to this project!
+
+**Thank you for your dedication and understanding as we continue refining our processes. As we explore this extraordinary new technology, we sincerely appreciate your involvement.**

open-interpreter/docs/NCU_MIGRATION_GUIDE.md

@@ -0,0 +1,254 @@
+# `0.2.0` Migration Guide
+
+Open Interpreter is [changing](https://changes.openinterpreter.com/log/the-new-computer-update). This guide will help you migrate your application to `0.2.0`, also called the _New Computer Update_ (NCU), the latest major version of Open Interpreter.
+
+## A New Start
+
+To start using Open Interpreter in Python, we now use a standard **class instantiation** format:
+
+```python
+# From the module `interpreter`, import the class `OpenInterpreter`
+from interpreter import OpenInterpreter
+
+# Create an instance of `OpenInterpreter` to use it
+agent = OpenInterpreter()
+agent.chat()
+```
+
+For convenience, we also provide an instance of `interpreter`, which you can import from the module (also called `interpreter`):
+
+```python
+ # From the module `interpreter`, import the included instance of `OpenInterpreter`
+from interpreter import interpreter
+
+interpreter.chat()
+```
+
+## New Parameters
+
+All stateless LLM attributes have been moved to `interpreter.llm`:
+
+- `interpreter.model` → `interpreter.llm.model`
+- `interpreter.api_key` → `interpreter.llm.api_key`
+- `interpreter.llm_supports_vision` → `interpreter.llm.supports_vision`
+- `interpreter.supports_function_calling` → `interpreter.llm.supports_functions`
+- `interpreter.max_tokens` → `interpreter.llm.max_tokens`
+- `interpreter.context_window` → `interpreter.llm.context_window`
+- `interpreter.temperature` → `interpreter.llm.temperature`
+- `interpreter.api_version` → `interpreter.llm.api_version`
+- `interpreter.api_base` → `interpreter.llm.api_base`
+
+This is reflected **1)** in Python applications using Open Interpreter and **2)** in your profile for OI's terminal interface, which can be edited via `interpreter --profiles`.
+
+## New Static Messages Structure
+
+- The array of messages is now flat, making the architecture more modular, and easier to adapt to new kinds of media in the future.
+- Each message holds only one kind of data. This yields more messages, but prevents large nested messages that can be difficult to parse.
+- This allows you to pass the full `messages` list into Open Interpreter as `interpreter.messages = message_list`.
+- Every message has a "role", which can be "assistant", "computer", or "user".
+- Every message has a "type", specifying the type of data it contains.
+- Every message has "content", which contains the data for the message.
+- Some messages have a "format" key, to specify the format of the content, like "path" or "base64.png".
+- The recipient of the message is specified by the "recipient" key, which can be "user" or "assistant". This is used to inform the LLM of who the message is intended for.
+
+```python
+[
+  {"role": "user", "type": "message", "content": "Please create a plot from this data and display it as an image and then as HTML."}, # implied format: text (only one format for type message)
+  {"role": "user", "type": "image", "format": "path", "content": "path/to/image.png"}
+  {"role": "user", "type": "file", "content": "/path/to/file.pdf"} # implied format: path (only one format for type file)
+  {"role": "assistant", "type": "message", "content": "Processing your request to generate a plot."} # implied format: text
+  {"role": "assistant", "type": "code", "format": "python", "content": "plot = create_plot_from_data('data')\ndisplay_as_image(plot)\ndisplay_as_html(plot)"}
+  {"role": "computer", "type": "image", "format": "base64.png", "content": "base64"}
+  {"role": "computer", "type": "code", "format": "html", "content": "<html>Plot in HTML format</html>"}
+  {"role": "computer", "type": "console", "format": "output", "content": "{HTML errors}"}
+  {"role": "assistant", "type": "message", "content": "Plot generated successfully."} # implied format: text
+]
+```
+
+## New Streaming Structure
+
+- The streaming data structure closely matches the static messages structure, with only a few differences.
+- Every streaming chunk has a "start" and "end" key, which are booleans that specify whether the chunk is the first or last chunk in the stream. This is what you should use to build messages from the streaming chunks.
+- There is a "confirmation" chunk type, which is used to confirm with the user that the code should be run. The "content" key of this chunk is a dictionary with a `code` and a `language` key.
+- Introducing more information per chunk is helpful in processing the streaming responses. Please take a look below for example code for processing streaming responses, in JavaScript.
+
+```python
+{"role": "assistant", "type": "message", "start": True}
+{"role": "assistant", "type": "message", "content": "Pro"}
+{"role": "assistant", "type": "message", "content": "cessing"}
+{"role": "assistant", "type": "message", "content": "your request"}
+{"role": "assistant", "type": "message", "content": "to generate a plot."}
+{"role": "assistant", "type": "message", "end": True}
+
+{"role": "assistant", "type": "code", "format": "python", "start": True}
+{"role": "assistant", "type": "code", "format": "python", "content": "plot = create_plot_from_data"}
+{"role": "assistant", "type": "code", "format": "python", "content": "('data')\ndisplay_as_image(plot)"}
+{"role": "assistant", "type": "code", "format": "python", "content": "\ndisplay_as_html(plot)"}
+{"role": "assistant", "type": "code", "format": "python", "end": True}
+
+# The computer will emit a confirmation chunk *before* running the code. You can break here to cancel the execution.
+
+{"role": "computer", "type": "confirmation", "format": "execution", "content": {
+    "type": "code",
+    "format": "python",
+    "content": "plot = create_plot_from_data('data')\ndisplay_as_image(plot)\ndisplay_as_html(plot)",
+}}
+
+{"role": "computer", "type": "console", "start": True}
+{"role": "computer", "type": "console", "format": "output", "content": "a printed statement"}
+{"role": "computer", "type": "console", "format": "active_line", "content": "1"}
+{"role": "computer", "type": "console", "format": "active_line", "content": "2"}
+{"role": "computer", "type": "console", "format": "active_line", "content": "3"}
+{"role": "computer", "type": "console", "format": "output", "content": "another printed statement"}
+{"role": "computer", "type": "console", "end": True}
+```
+
+## Tips and Best Practices
+
+- Adding an `id` and a `created_at` field to messages can be helpful to manipulate the messages later on.
+- If you want your application to run the code instead of OI, then your app will act as the `computer`. This means breaking from the stream once OI emits a confirmation chunk (`{'role': 'computer', 'type': 'confirmation' ...}`) to prevent OI from running the code. When you run code, grab the message history via `messages = interpreter.messages`, then simply mimic the `computer` format above by appending new `{'role': 'computer' ...}` messages, then run `interpreter.chat(messages)`.
+- Open Interpreter is designed to stop code execution when the stream is disconnected. Use this to your advantage to add a "Stop" button to the UI.
+- Setting up your Python server to send errors and exceptions to the client can be helpful for debugging and generating error messages.
+
+## Example Code
+
+### Types
+
+Python:
+
+```python
+class Message:
+    role: Union["user", "assistant", "computer"]
+    type: Union["message", "code", "image", "console", "file", "confirmation"]
+    format: Union["output", "path", "base64.png", "base64.jpeg", "python", "javascript", "shell", "html", "active_line", "execution"]
+    recipient: Union["user", "assistant"]
+    content: Union[str, dict]  # dict should have 'code' and 'language' keys, this is only for confirmation messages
+
+class StreamingChunk(Message):
+    start: bool
+    end: bool
+```
+
+TypeScript:
+
+```typescript
+interface Message {
+  role: "user" | "assistant" | "computer";
+  type: "message" | "code" | "image" | "console" | "file", | "confirmation";
+  format: "output" | "path" | "base64.png" | "base64.jpeg" | "python" | "javascript" | "shell" | "html" | "active_line", | "execution";
+  recipient: "user" | "assistant";
+  content: string | { code: string; language: string };
+}
+```
+
+```typescript
+interface StreamingChunk extends Message {
+  start: boolean;
+  end: boolean;
+}
+```
+
+### Handling streaming chunks
+
+Here is a minimal example of how to handle streaming chunks in JavaScript. This example assumes that you are using a Python server to handle the streaming requests, and that you are using a JavaScript client to send the requests and handle the responses. See the main repository README for an example FastAPI server.
+
+```javascript
+//Javascript
+
+let messages = []; //variable to hold all messages
+let currentMessageIndex = 0; //variable to keep track of the current message index
+let isGenerating = false; //variable to stop the stream
+
+// Function to send a POST request to the OI
+async function sendRequest() {
+  // Temporary message to hold the message that is being processed
+  try {
+    // Define parameters for the POST request, add at least the full messages array, but you may also consider adding any other OI parameters here, like auto_run, local, etc.
+    const params = {
+      messages,
+    };
+
+    //Define a controller to allow for aborting the request
+    const controller = new AbortController();
+    const { signal } = controller;
+
+    // Send the POST request to your Python server endpoint
+    const interpreterCall = await fetch("https://YOUR_ENDPOINT/", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(params),
+      signal,
+    });
+
+    // Throw an error if the request was not successful
+    if (!interpreterCall.ok) {
+      console.error("Interpreter didn't respond with 200 OK");
+      return;
+    }
+
+    // Initialize a reader for the response body
+    const reader = interpreterCall.body.getReader();
+
+    isGenerating = true;
+    while (true) {
+      const { value, done } = await reader.read();
+
+      // Break the loop if the stream is done
+      if (done) {
+        break;
+      }
+      // If isGenerating is set to false, cancel the reader and break the loop. This will halt the execution of the code run by OI as well
+      if (!isGenerating) {
+        await reader.cancel();
+        controller.abort();
+        break;
+      }
+      // Decode the stream and split it into lines
+      const text = new TextDecoder().decode(value);
+      const lines = text.split("\n");
+      lines.pop(); // Remove last empty line
+
+      // Process each line of the response
+      for (const line of lines) {
+        const chunk = JSON.parse(line);
+        await processChunk(chunk);
+      }
+    }
+    //Stream has completed here, so run any code that needs to be run after the stream has finished
+    if (isGenerating) isGenerating = false;
+  } catch (error) {
+    console.error("An error occurred:", error);
+  }
+}
+
+//Function to process each chunk of the stream, and create messages
+function processChunk(chunk) {
+  if (chunk.start) {
+    const tempMessage = {};
+    //add the new message's data to the tempMessage
+    tempMessage.role = chunk.role;
+    tempMessage.type = chunk.type;
+    tempMessage.content = "";
+    if (chunk.format) tempMessage.format = chunk.format;
+    if (chunk.recipient) tempMessage.recipient = chunk.recipient;
+
+    //add the new message to the messages array, and set the currentMessageIndex to the index of the new message
+    messages.push(tempMessage);
+    currentMessageIndex = messages.length - 1;
+  }
+
+  //Handle active lines for code blocks
+  if (chunk.format === "active_line") {
+    messages[currentMessageIndex].activeLine = chunk.content;
+  } else if (chunk.end && chunk.type === "console") {
+    messages[currentMessageIndex].activeLine = null;
+  }
+
+  //Add the content of the chunk to current message, avoiding adding the content of the active line
+  if (chunk.content && chunk.format !== "active_line") {
+    messages[currentMessageIndex].content += chunk.content;
+  }
+}
+```

open-interpreter/docs/README_DE.md

@@ -0,0 +1,131 @@
+<h1 align="center">● Open Interpreter</h1>
+
+<p align="center">
+    <a href="https://discord.gg/6p3fD6rBVm">
+        <img alt="Discord" src="https://img.shields.io/discord/1146610656779440188?logo=discord&style=flat&logoColor=white">
+    </a>
+    <a href="README_ES.md"> <img src="https://img.shields.io/badge/Español-white.svg" alt="ES doc"/></a>
+    <a href="README_JA.md"><img src="https://img.shields.io/badge/ドキュメント-日本語-white.svg" alt="JA doc"></a>
+    <a href="README_ZH.md"><img src="https://img.shields.io/badge/文档-中文版-white.svg" alt="ZH doc"></a>
+    <a href="README.md"><img src="https://img.shields.io/badge/english-document-white.svg" alt="EN doc"></a>
+    <img src="https://img.shields.io/static/v1?label=license&message=MIT&color=white&style=flat" alt="License">
+    <br><br>
+    <b>Lassen Sie Sprachmodelle Code auf Ihrem Computer ausführen.</b><br>
+    Eine Open-Source, lokal laufende Implementierung von OpenAIs Code-Interpreter.<br>
+    <br><a href="https://openinterpreter.com">Erhalten Sie frühen Zugang zur Desktop-Anwendung.</a><br>
+</p>
+
+<br>
+
+![poster](https://github.com/KillianLucas/open-interpreter/assets/63927363/08f0d493-956b-4d49-982e-67d4b20c4b56)
+
+<br>
+
+```shell
+pip install open-interpreter
+```
+
+```shell
+interpreter
+```
+
+<br>
+
+**Open Interpreter** ermöglicht es LLMs (Language Models), Code (Python, Javascript, Shell und mehr) lokal auszuführen. Sie können mit Open Interpreter über eine ChatGPT-ähnliche Schnittstelle in Ihrem Terminal chatten, indem Sie $ interpreter nach der Installation ausführen.
+
+Dies bietet eine natürliche Sprachschnittstelle zu den allgemeinen Fähigkeiten Ihres Computers:
+
+- Erstellen und bearbeiten Sie Fotos, Videos, PDFs usw.
+- Steuern Sie einen Chrome-Browser, um Forschungen durchzuführen
+- Darstellen, bereinigen und analysieren Sie große Datensätze
+- ...usw.
+
+**⚠️ Hinweis: Sie werden aufgefordert, Code zu genehmigen, bevor er ausgeführt wird.**
+
+<br>
+
+## Demo
+
+https://github.com/KillianLucas/open-interpreter/assets/63927363/37152071-680d-4423-9af3-64836a6f7b60
+
+#### Eine interaktive Demo ist auch auf Google Colab verfügbar:
+
+[![In Colab öffnen](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1WKmRXZgsErej2xUriKzxrEAXdxMSgWbb?usp=sharing)
+
+## Schnellstart
+
+```shell
+pip install open-interpreter
+```
+
+### Terminal
+
+Nach der Installation führen Sie einfach `interpreter` aus:
+
+```shell
+interpreter
+```
+
+### Python
+
+```python
+from interpreter import interpreter
+
+interpreter.chat("Stellen Sie AAPL und METAs normalisierte Aktienpreise dar") # Führt einen einzelnen Befehl aus
+interpreter.chat() # Startet einen interaktiven Chat
+```
+
+## Vergleich zu ChatGPTs Code Interpreter
+
+OpenAIs Veröffentlichung des [Code Interpreters](https://openai.com/blog/chatgpt-plugins#code-interpreter) mit GPT-4 bietet eine fantastische Möglichkeit, reale Aufgaben mit ChatGPT zu erledigen.
+
+Allerdings ist OpenAIs Dienst gehostet, Closed-Source und stark eingeschränkt:
+
+- Kein Internetzugang.
+- [Begrenzte Anzahl vorinstallierter Pakete](https://wfhbrian.com/mastering-chatgpts-code-interpreter-list-of-python-packages/).
+- 100 MB maximale Uploadgröße, 120.0 Sekunden Laufzeitlimit.
+- Der Zustand wird gelöscht (zusammen mit allen generierten Dateien oder Links), wenn die Umgebung abstirbt.
+
+---
+
+Open Interpreter überwindet diese Einschränkungen, indem es in Ihrer lokalen Umgebung läuft. Es hat vollen Zugang zum Internet, ist nicht durch Zeit oder Dateigröße eingeschränkt und kann jedes Paket oder jede Bibliothek nutzen.
+
+Dies kombiniert die Kraft von GPT-4s Code Interpreter mit der Flexibilität Ihrer lokalen Maschine.
+
+## Sicherheitshinweis
+
+Da generierter Code in deiner lokalen Umgebung ausgeführt wird, kann er mit deinen Dateien und Systemeinstellungen interagieren, was potenziell zu unerwarteten Ergebnissen wie Datenverlust oder Sicherheitsrisiken führen kann.
+
+**⚠️ Open Interpreter wird um Nutzerbestätigung bitten, bevor Code ausgeführt wird.**
+
+Du kannst `interpreter -y` ausführen oder `interpreter.auto_run = True` setzen, um diese Bestätigung zu umgehen, in diesem Fall:
+
+- Sei vorsichtig bei Befehlsanfragen, die Dateien oder Systemeinstellungen ändern.
+- Beobachte Open Interpreter wie ein selbstfahrendes Auto und sei bereit, den Prozess zu beenden, indem du dein Terminal schließt.
+- Betrachte die Ausführung von Open Interpreter in einer eingeschränkten Umgebung wie Google Colab oder Replit. Diese Umgebungen sind isolierter und reduzieren das Risiko der Ausführung willkürlichen Codes.
+
+Es gibt **experimentelle** Unterstützung für einen [Sicherheitsmodus](docs/SAFE_MODE.md), um einige Risiken zu mindern.
+
+## Wie funktioniert es?
+
+Open Interpreter rüstet ein [funktionsaufrufendes Sprachmodell](https://platform.openai.com/docs/guides/gpt/function-calling) mit einer `exec()`-Funktion aus, die eine `language` (wie "Python" oder "JavaScript") und auszuführenden `code` akzeptiert.
+
+Wir streamen dann die Nachrichten des Modells, Code und die Ausgaben deines Systems zum Terminal als Markdown.
+
+# Mitwirken
+
+Danke für dein Interesse an der Mitarbeit! Wir begrüßen die Beteiligung der Gemeinschaft.
+
+Bitte sieh dir unsere [Richtlinien für Mitwirkende](docs/CONTRIBUTING.md) für weitere Details an, wie du dich einbringen kannst.
+
+## Lizenz
+
+Open Interpreter ist unter der MIT-Lizenz lizenziert. Du darfst die Software verwenden, kopieren, modifizieren, verteilen, unterlizenzieren und Kopien der Software verkaufen.
+
+**Hinweis**: Diese Software ist nicht mit OpenAI affiliiert.
+
+> Zugriff auf einen Junior-Programmierer zu haben, der mit der Geschwindigkeit deiner Fingerspitzen arbeitet ... kann neue Arbeitsabläufe mühelos und effizient machen sowie das Programmieren einem neuen Publikum öffnen.
+>
+> — _OpenAIs Code Interpreter Release_
+
+<br>

open-interpreter/docs/README_ES.md

@@ -0,0 +1,413 @@
+<h1 align="center">● Intérprete Abierto</h1>
+
+<p align="center">
+    <a href="https://discord.gg/Hvz9Axh84z">
+        <img alt="Discord" src="https://img.shields.io/discord/1146610656779440188?logo=discord&style=flat&logoColor=white"/></a>
+    <a href="../README.md"><img src="https://img.shields.io/badge/english-document-white.svg" alt="EN doc"></a>
+    <a href="docs/README_JA.md"><img src="https://img.shields.io/badge/ドキュメント-日本語-white.svg" alt="JA doc"/></a>
+    <a href="docs/README_ZH.md"> <img src="https://img.shields.io/badge/文档-中文版-white.svg" alt="ZH doc"/></a>
+    <a href="docs/README_IN.md"> <img src="https://img.shields.io/badge/Hindi-white.svg" alt="IN doc"/></a>
+    <img src="https://img.shields.io/static/v1?label=licencia&message=AGPL&color=white&style=flat" alt="License"/>
+    <br>
+    <br>
+    <br><a href="https://0ggfznkwh4j.typeform.com/to/G21i9lJ2">Obtenga acceso temprano a la aplicación de escritorio</a>‎ ‎ |‎ ‎ <a href="https://docs.openinterpreter.com/">Documentación</a><br>
+</p>
+
+<br>
+
+![poster](https://github.com/KillianLucas/open-interpreter/assets/63927363/08f0d493-956b-4d49-982e-67d4b20c4b56)
+
+<br>
+<p align="center">
+<strong>La Nueva Actualización del Computador</strong> presenta <strong><code>--os</code></strong> y una nueva <strong>API de Computadora</strong>. <a href="https://changes.openinterpreter.com/log/the-new-computer-update">Lea más →</a>
+</p>
+<br>
+
+```shell
+pip install open-interpreter
+```
+
+> ¿No funciona? Lea nuestra [guía de configuración](https://docs.openinterpreter.com/getting-started/setup).
+
+```shell
+interpreter
+```
+
+<br>
+
+**Intérprete Abierto** permite a los LLMs ejecutar código (Python, JavaScript, Shell, etc.) localmente. Puede chatear con Intérprete Abierto a través de una interfaz de chat como ChatGPT en su terminal después de instalar.
+
+Esto proporciona una interfaz de lenguaje natural para las capacidades generales de su computadora:
+
+- Crear y editar fotos, videos, PDF, etc.
+- Controlar un navegador de Chrome para realizar investigaciones
+- Graficar, limpiar y analizar conjuntos de datos grandes
+- ... etc.
+
+**⚠️ Nota: Se le pedirá que apruebe el código antes de ejecutarlo.**
+
+<br>
+
+## Demo
+
+https://github.com/KillianLucas/open-interpreter/assets/63927363/37152071-680d-4423-9af3-64836a6f7b60
+
+#### También hay disponible una demo interactiva en Google Colab:
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1WKmRXZgsErej2xUriKzxrEAXdxMSgWbb?usp=sharing)
+
+#### Además, hay un ejemplo de interfaz de voz inspirada en _Her_:
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1NojYGHDgxH6Y1G1oxThEBBb2AtyODBIK)
+
+## Inicio Rápido
+
+```shell
+pip install open-interpreter
+```
+
+### Terminal
+
+Después de la instalación, simplemente ejecute `interpreter`:
+
+```shell
+interpreter
+```
+
+### Python
+
+```python
+from interpreter import interpreter
+
+interpreter.chat("Plot AAPL and META's normalized stock prices") # Ejecuta un comando sencillo
+interpreter.chat() # Inicia una sesión de chat interactiva
+```
+
+### GitHub Codespaces
+
+Presione la tecla `,` en la página de GitHub de este repositorio para crear un espacio de códigos. Después de un momento, recibirá un entorno de máquina virtual en la nube con Interprete Abierto pre-instalado. Puede entonces empezar a interactuar con él directamente y confirmar su ejecución de comandos del sistema sin preocuparse por dañar el sistema.
+
+## Comparación con el Intérprete de Código de ChatGPT
+
+El lanzamiento de [Intérprete de Código](https://openai.com/blog/chatgpt-plugins#code-interpreter) de OpenAI con GPT-4 presenta una oportunidad fantástica para realizar tareas del mundo real con ChatGPT.
+
+Sin embargo, el servicio de OpenAI está alojado, su codigo es cerrado y está fuertemente restringido:
+
+- No hay acceso a Internet.
+- [Conjunto limitado de paquetes preinstalados](https://wfhbrian.com/mastering-chatgpts-code-interpreter-list-of-python-packages/).
+- Límite de 100 MB de carga, límite de tiempo de 120.0 segundos.
+- El estado se elimina (junto con cualquier archivo generado o enlace) cuando el entorno se cierra.
+
+---
+
+Intérprete Abierto supera estas limitaciones al ejecutarse en su entorno local. Tiene acceso completo a Internet, no está restringido por tiempo o tamaño de archivo y puede utilizar cualquier paquete o libreria.
+
+Esto combina el poder del Intérprete de Código de GPT-4 con la flexibilidad de su entorno de desarrollo local.
+
+## Comandos
+
+**Actualización:** La Actualización del Generador (0.1.5) introdujo streaming:
+
+```python
+message = "¿Qué sistema operativo estamos utilizando?"
+
+for chunk in interpreter.chat(message, display=False, stream=True):
+    print(chunk)
+```
+
+### Chat Interactivo
+
+Para iniciar una sesión de chat interactiva en su terminal, puede ejecutar `interpreter` desde la línea de comandos:
+
+```shell
+interpreter
+```
+
+O `interpreter.chat()` desde un archivo `.py`:
+
+```python
+interpreter.chat()
+```
+
+**Puede también transmitir cada trozo:**
+
+```python
+message = "¿Qué sistema operativo estamos utilizando?"
+
+for chunk in interpreter.chat(message, display=False, stream=True):
+    print(chunk)
+```
+
+### Chat Programático
+
+Para un control más preciso, puede pasar mensajes directamente a `.chat(message)`:
+
+```python
+interpreter.chat("Añade subtítulos a todos los videos en /videos.")
+
+# ... Transmite salida a su terminal, completa tarea ...
+
+interpreter.chat("Estos se ven bien, pero ¿pueden hacer los subtítulos más grandes?")
+
+# ...
+```
+
+### Iniciar un nuevo chat
+
+En Python, Intérprete Abierto recuerda el historial de conversación. Si desea empezar de nuevo, puede resetearlo:
+
+```python
+interpreter.messages = []
+```
+
+### Guardar y Restaurar Chats
+
+`interpreter.chat()` devuelve una lista de mensajes, que puede utilizar para reanudar una conversación con `interpreter.messages = messages`:
+
+```python
+messages = interpreter.chat("Mi nombre es Killian.") # Guarda mensajes en 'messages'
+interpreter.messages = [] # Resetear Intérprete ("Killian" será olvidado)
+
+interpreter.messages = messages # Reanuda chat desde 'messages' ("Killian" será recordado)
+```
+
+### Personalizar el Mensaje del Sistema
+
+Puede inspeccionar y configurar el mensaje del sistema de Intérprete Abierto para extender su funcionalidad, modificar permisos o darle más contexto.
+
+```python
+interpreter.system_message += """
+Ejecute comandos de shell con -y para que el usuario no tenga que confirmarlos.
+"""
+print(interpreter.system_message)
+```
+
+### Cambiar el Modelo de Lenguaje
+
+Intérprete Abierto utiliza [LiteLLM](https://docs.litellm.ai/docs/providers/) para conectarse a modelos de lenguaje hospedados.
+
+Puede cambiar el modelo estableciendo el parámetro de modelo:
+
+```shell
+interpreter --model gpt-3.5-turbo
+interpreter --model claude-2
+interpreter --model command-nightly
+```
+
+En Python, establezca el modelo en el objeto:
+
+```python
+interpreter.llm.model = "gpt-3.5-turbo"
+```
+
+[Encuentre la cadena adecuada para su modelo de lenguaje aquí.](https://docs.litellm.ai/docs/providers/)
+
+### Ejecutar Intérprete Abierto localmente
+
+#### Terminal
+
+Intérprete Abierto puede utilizar un servidor de OpenAI compatible para ejecutar modelos localmente. (LM Studio, jan.ai, ollama, etc.)
+
+Simplemente ejecute `interpreter` con la URL de base de API de su servidor de inferencia (por defecto, `http://localhost:1234/v1` para LM Studio):
+
+```shell
+interpreter --api_base "http://localhost:1234/v1" --api_key "fake_key"
+```
+
+O puede utilizar Llamafile sin instalar software adicional simplemente ejecutando:
+
+```shell
+interpreter --local
+```
+
+Para una guía mas detallada, consulte [este video de Mike Bird](https://www.youtube.com/watch?v=CEs51hGWuGU?si=cN7f6QhfT4edfG5H)
+
+**Cómo ejecutar LM Studio en segundo plano.**
+
+1. Descargue [https://lmstudio.ai/](https://lmstudio.ai/) luego ejecutelo.
+2. Seleccione un modelo, luego haga clic **↓ Descargar**.
+3. Haga clic en el botón **↔️** en la izquierda (debajo de 💬).
+4. Seleccione su modelo en la parte superior, luego haga clic **Iniciar Servidor**.
+
+Una vez que el servidor esté funcionando, puede empezar su conversación con Intérprete Abierto.
+
+> **Nota:** El modo local establece su `context_window` en 3000 y su `max_tokens` en 1000. Si su modelo tiene requisitos diferentes, ajuste estos parámetros manualmente (ver a continuación).
+
+#### Python
+
+Nuestro paquete de Python le da más control sobre cada ajuste. Para replicar y conectarse a LM Studio, utilice estos ajustes:
+
+```python
+from interpreter import interpreter
+
+interpreter.offline = True # Desactiva las características en línea como Procedimientos Abiertos
+interpreter.llm.model = "openai/x" # Indica a OI que envíe mensajes en el formato de OpenAI
+interpreter.llm.api_key = "fake_key" # LiteLLM, que utilizamos para hablar con LM Studio, requiere esto
+interpreter.llm.api_base = "http://localhost:1234/v1" # Apunta esto a cualquier servidor compatible con OpenAI
+
+interpreter.chat()
+```
+
+#### Ventana de Contexto, Tokens Máximos
+
+Puede modificar los `max_tokens` y `context_window` (en tokens) de los modelos locales.
+
+Para el modo local, ventanas de contexto más cortas utilizarán menos RAM, así que recomendamos intentar una ventana mucho más corta (~1000) si falla o si es lenta. Asegúrese de que `max_tokens` sea menor que `context_window`.
+
+```shell
+interpreter --local --max_tokens 1000 --context_window 3000
+```
+
+### Modo Detallado
+
+Para ayudarle a inspeccionar Intérprete Abierto, tenemos un modo `--verbose` para depuración.
+
+Puede activar el modo detallado utilizando el parámetro (`interpreter --verbose`), o en plena sesión:
+
+```shell
+$ interpreter
+...
+> %verbose true <- Activa el modo detallado
+
+> %verbose false <- Desactiva el modo verbose
+```
+
+### Comandos de Modo Interactivo
+
+En el modo interactivo, puede utilizar los siguientes comandos para mejorar su experiencia. Aquí hay una lista de comandos disponibles:
+
+**Comandos Disponibles:**
+
+- `%verbose [true/false]`: Activa o desactiva el modo detallado. Sin parámetros o con `true` entra en modo detallado.
+Con `false` sale del modo verbose.
+- `%reset`: Reinicia la sesión actual de conversación.
+- `%undo`: Elimina el mensaje de usuario previo y la respuesta del AI del historial de mensajes.
+- `%tokens [prompt]`: (_Experimental_) Calcula los tokens que se enviarán con el próximo prompt como contexto y estima su costo. Opcionalmente, calcule los tokens y el costo estimado de un `prompt` si se proporciona. Depende de [LiteLLM's `cost_per_token()` method](https://docs.litellm.ai/docs/completion/token_usage#2-cost_per_token) para costos estimados.
+- `%help`: Muestra el mensaje de ayuda.
+
+### Configuración / Perfiles
+
+Intérprete Abierto permite establecer comportamientos predeterminados utilizando archivos `yaml`.
+
+Esto proporciona una forma flexible de configurar el intérprete sin cambiar los argumentos de línea de comandos cada vez.
+
+Ejecutar el siguiente comando para abrir el directorio de perfiles:
+
+```
+interpreter --profiles
+```
+
+Puede agregar archivos `yaml` allí. El perfil predeterminado se llama `default.yaml`.
+
+#### Perfiles Múltiples
+
+Intérprete Abierto admite múltiples archivos `yaml`, lo que permite cambiar fácilmente entre configuraciones:
+
+```
+interpreter --profile my_profile.yaml
+```
+
+## Servidor de FastAPI de ejemplo
+
+El generador actualiza permite controlar Intérprete Abierto a través de puntos de conexión HTTP REST:
+
+```python
+# server.py
+
+from fastapi import FastAPI
+from fastapi.responses import StreamingResponse
+from interpreter import interpreter
+
+app = FastAPI()
+
+@app.get("/chat")
+def chat_endpoint(message: str):
+    def event_stream():
+        for result in interpreter.chat(message, stream=True):
+            yield f"data: {result}\n\n"
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+@app.get("/history")
+def history_endpoint():
+    return interpreter.messages
+```
+
+```shell
+pip install fastapi uvicorn
+uvicorn server:app --reload
+```
+
+Puede iniciar un servidor idéntico al anterior simplemente ejecutando `interpreter.server()`.
+
+## Android
+
+La guía paso a paso para instalar Intérprete Abierto en su dispositivo Android se encuentra en el [repo de open-interpreter-termux](https://github.com/MikeBirdTech/open-interpreter-termux).
+
+## Aviso de Seguridad
+
+Ya que el código generado se ejecuta en su entorno local, puede interactuar con sus archivos y configuraciones del sistema, lo que puede llevar a resultados inesperados como pérdida de datos o riesgos de seguridad.
+
+**⚠️ Intérprete Abierto le pedirá que apruebe el código antes de ejecutarlo.**
+
+Puede ejecutar `interpreter -y` o establecer `interpreter.auto_run = True` para evitar esta confirmación, en cuyo caso:
+
+- Sea cuidadoso al solicitar comandos que modifican archivos o configuraciones del sistema.
+- Vigile Intérprete Abierto como si fuera un coche autónomo y esté preparado para terminar el proceso cerrando su terminal.
+- Considere ejecutar Intérprete Abierto en un entorno restringido como Google Colab o Replit. Estos entornos son más aislados, reduciendo los riesgos de ejecutar código arbitrario.
+
+Hay soporte **experimental** para un [modo seguro](docs/SAFE_MODE.md) para ayudar a mitigar algunos riesgos.
+
+## ¿Cómo Funciona?
+
+Intérprete Abierto equipa un [modelo de lenguaje de llamada a funciones](https://platform.openai.com/docs/guides/gpt/function-calling) con una función `exec()`, que acepta un `lenguaje` (como "Python" o "JavaScript") y `código` para ejecutar.
+
+Luego, transmite los mensajes del modelo, el código y las salidas del sistema a la terminal como Markdown.
+
+# Acceso a la Documentación Offline
+
+La documentación completa está disponible en línea sin necesidad de conexión a Internet.
+
+[Node](https://nodejs.org/en) es un requisito previo:
+
+- Versión 18.17.0 o cualquier versión posterior 18.x.x.
+- Versión 20.3.0 o cualquier versión posterior 20.x.x.
+- Cualquier versión a partir de 21.0.0 sin límite superior especificado.
+
+Instale [Mintlify](https://mintlify.com/):
+
+```bash
+npm i -g mintlify@latest
+```
+
+Cambia a la carpeta de documentos y ejecuta el comando apropiado:
+
+```bash
+# Suponiendo que estás en la carpeta raíz del proyecto
+cd ./docs
+
+# Ejecute el servidor de documentación
+mintlify dev
+```
+
+Una nueva ventana del navegador debería abrirse. La documentación estará disponible en [http://localhost:3000](http://localhost:3000) mientras el servidor de documentación esté funcionando.
+
+# Contribuyendo
+
+¡Gracias por su interés en contribuir! Damos la bienvenida a la implicación de la comunidad.
+
+Por favor, consulte nuestras [directrices de contribución](docs/CONTRIBUTING.md) para obtener más detalles sobre cómo involucrarse.
+
+# Roadmap
+
+Visite [nuestro roadmap](https://github.com/KillianLucas/open-interpreter/blob/main/docs/ROADMAP.md) para ver el futuro de Intérprete Abierto.
+
+**Nota:** Este software no está afiliado con OpenAI.
+
+![thumbnail-ncu](https://github.com/KillianLucas/open-interpreter/assets/63927363/1b19a5db-b486-41fd-a7a1-fe2028031686)
+
+> Tener acceso a un programador junior trabajando a la velocidad de su dedos... puede hacer que los nuevos flujos de trabajo sean sencillos y eficientes, además de abrir los beneficios de la programación a nuevas audiencias.
+>
+> — _Lanzamiento del intérprete de código de OpenAI_
+
+<br>

open-interpreter/docs/README_IN.md

@@ -0,0 +1,258 @@
+<h1 align="center">● Open Interpreter</h1>
+
+<p align="center">
+    <a href="https://discord.gg/6p3fD6rBVm">
+        <img alt="Discord" src="https://img.shields.io/discord/1146610656779440188?logo=discord&style=flat&logoColor=white"/>
+    </a>
+    <a href="README_ES.md"> <img src="https://img.shields.io/badge/Español-white.svg" alt="ES doc"/></a>
+    <a href="README_JA.md"><img src="https://img.shields.io/badge/ドキュメント-日本語-white.svg" alt="JA doc"/></a>
+    <a href="README_ZH.md"><img src="https://img.shields.io/badge/文档-中文版-white.svg" alt="ZH doc"/></a>
+    <a href="README_IN.md"><img src="https://img.shields.io/badge/Document-Hindi-white.svg" alt="IN doc"/></a>
+    <img src="https://img.shields.io/static/v1?label=license&message=MIT&color=white&style=flat" alt="License"/>
+    <br><br>
+    <b>अपने कंप्यूटर पर कोड चलाने के लिए भाषा मॉडल को चलाएं।</b><br>
+    ओपनएआई कोड इंटरप्रेटर का एक ओपन-सोर्स, स्थानीय चलने वाला अमल।<br>
+    <br><a href="https://openinterpreter.com">डेस्कटॉप एप्लिकेशन को पहले से ही उपयोग करने के लिए एरली एक्सेस प्राप्त करें।</a><br>
+</p>
+
+<br>
+
+![poster](https://github.com/KillianLucas/open-interpreter/assets/63927363/08f0d493-956b-4d49-982e-67d4b20c4b56)
+
+<br>
+
+```shell
+pip install open-interpreter
+```
+
+```shell
+interpreter
+```
+
+<br>
+
+**ओपन इंटरप्रेटर** एलएलएम कोड (पायथन, जावास्क्रिप्ट, शेल, और अधिक) को स्थानीय रूप से चलाने की अनुमति देता है। आप इंस्टॉल करने के बाद अपने टर्मिनल में `$ interpreter` चलाकर ओपन इंटरप्रेटर के साथ एक चैटजीपीटी-जैसे इंटरफ़ेस के माध्यम से चैट कर सकते हैं।
+
+यह आपके कंप्यूटर की सामान्य-उद्देश्य क्षमताओं के लिए एक प्राकृतिक भाषा इंटरफ़ेस प्रदान करता है:
+
+- फ़ोटो, वीडियो, पीडीएफ़ आदि बनाएँ और संपादित करें।
+- अनुसंधान करने के लिए एक क्रोम ब्राउज़र को नियंत्रित करें।
+- बड़े डेटासेट को प्लॉट करें, साफ करें और विश्लेषण करें।
+- ...आदि।
+
+**⚠️ ध्यान दें: कोड को चलाने से पहले आपसे मंज़ूरी मांगी जाएगी।**
+
+<br>
+
+## डेमो
+
+[![कोलैब में खोलें](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1WKmRXZgsErej2xUriKzxrEAXdxMSgWbb?usp=sharing)
+
+## त्वरित प्रारंभ
+
+```shell
+pip install open-interpreter
+```
+
+### टर्मिनल
+
+इंस्टॉलेशन के बाद, सीधे `interpreter` चलाएं:
+
+```shell
+interpreter
+```
+
+### पायथन
+
+```python
+from interpreter import interpreter
+
+interpreter.chat("AAPL और META के मानकीकृत स्टॉक मूल्यों का चित्रित करें") # एकल कमांड को निष्पादित करता है
+interpreter.chat() # एक इंटरैक्टिव चैट शुरू करता है
+```
+
+## ChatGPT के कोड इंटरप्रेटर के साथ तुलना
+
+ओपनएआई द्वारा [कोड इंटरप्रेटर](https://openai.com/blog/chatgpt-plugins#code-interpreter) का विमोचन। GPT-4 के साथ यह एक शानदार अवसर प्रस्तुत करता है जिससे ChatGPT के साथ वास्तविक दुनिया के कार्यों को पूरा करने का संभावना होती है।
+
+हालांकि, ओपनएआई की सेवा होस्ट की जाती है, क्लोज़-स्रोत है और गहरी प्रतिबंधित है।
+
+यहां दिए गए नियमों के अनुसार, चैटजीपीटी कोड इंटरप्रेटर के लिए निर्धारित नियमों को हिंदी में अनुवाद किया ���ा सकता है:
+
+- कोई इंटरनेट पहुंच नहीं होती।
+- [प्रतिष्ठित सेट की सीमित संख्या के पहले स्थापित पैकेज](https://wfhbrian.com/mastering-chatgpts-code-interpreter-list-of-python-packages/) होते हैं।
+- 100 एमबी तक की अधिकतम अपलोड सीमा होती है।
+- 120.0 सेकंड की रनटाइम सीमा होती है।
+- जब एनवायरनमेंट समाप्त होता है, तो स्थिति साफ हो जाती है (साथ ही उत्पन्न किए गए फ़ाइल या लिंक भी)।
+
+---
+
+ओपन इंटरप्रेटर इन सीमाओं को पार करता है जो आपके स्थानीय वातावरण पर चलता है। इसके पास इंटरनेट का पूरा उपयोग होता है, समय या फ़ाइल का आकार पर प्रतिबंध नहीं होता है, और किसी भी पैकेज या लाइब्रेरी का उपयोग कर सकता है।
+
+यह GPT-4 के कोड इंटरप्रेटर की शक्ति को आपके स्थानीय विकास वातावरण की लचीलापन के साथ मिलाता है।
+
+## Commands
+
+### Interactive Chat
+
+To start an interactive chat in your terminal, either run `interpreter` from the command line:
+
+```shell
+interpreter
+```
+
+Or `interpreter.chat()` from a .py file:
+
+```python
+interpreter.chat()
+```
+
+## कमांड
+
+### इंटरैक्टिव चैट
+
+अपने टर्मिनल में इंटरैक्टिव चैट शुरू करने के लिए, या तो कमांड लाइन से `interpreter` चलाएँ:
+
+```shell
+interpreter
+```
+
+या एक .py फ़ाइल से `interpreter.chat()` चलाएँ:
+
+````python
+interpreter.chat()
+
+### प्रोग्रामेटिक चैट
+
+और सटीक नियंत्रण के लिए, आप सीधे `.chat(message)` को संदेश पास कर सकते हैं:
+
+```python
+interpreter.chat("सभी वीडियो में उपशीर्षक जोड़ें /videos में।")
+
+# ... आपके टर्मिनल में आउटपुट स्ट्रीम करता है, कार्य पूरा करता है ...
+
+interpreter.chat("ये बड़े दिख रहे हैं लेकिन क्या आप उपशीर्षक को और बड़ा कर सकते हैं?")
+
+# ...
+````
+
+### नया चैट शुरू करें
+
+Python में, ओपन इंटरप्रेटर संवाद इतिहास को याद रखता है। यदि आप एक नया आरंभ करना चाहते हैं, तो आप इसे रीसेट कर सकते हैं:
+
+```python
+interpreter.messages = []
+```
+
+### चैट सहेजें और पुनर्स्थापित करें
+
+```python
+messages = interpreter.chat("मेरा नाम किलियन है।") # संदेशों को 'messages' में सहेजें
+
+interpreter.messages = messages # 'messages' से चैट को फिर से शुरू करें ("किलियन" याद रखा जाएगा)
+```
+
+### सिस्टम संदेश कस्टमाइज़ करें
+
+आप ओपन इंटरप्रेटर के सिस्टम संदेश की जांच और कॉन्फ़िगर कर सकते हैं ताकि इसकी क्षमता को विस्तारित किया जा सके, अनुमतियों को संशोधित किया जा सके, या इसे अधिक संदर्भ दिया जा सके।
+
+```python
+interpreter.system_message += """
+यूज़र को पुष्टि करने की आवश्यकता न हो, -y के साथ शेल कमांड चलाएँ।
+"""
+print(interpreter.system_message)
+```
+
+### मॉडल बदलें
+
+`gpt-3.5-turbo` के लिए तेज़ मोड का उपयोग करें:
+
+```shell
+interpreter --fast
+```
+
+Python में, आपको मॉडल को मैन्युअली सेट करने की आवश्यकता होगी:
+
+```python
+interpreter.llm.model = "gpt-3.5-turbo"
+```
+
+### ओपन इंटरप्रेटर को स्थानीय र��प से चलाना
+
+```shell
+interpreter --local
+```
+
+#### स्थानीय मॉडल पैरामीटर
+
+आप स्थानीय रूप से चल रहे मॉडल की `max_tokens` और `context_window` (टोकन में) आसानी से संशोधित कर सकते हैं।
+
+छोटे संदर्भ विंडो का उपयोग करने से कम RAM का उपयोग होगा, इसलिए यदि GPU असफल हो रहा है तो हम एक छोटी विंडो की कोशिश करने की सलाह देते हैं।
+
+```shell
+interpreter --max_tokens 2000 --context_window 16000
+```
+
+### डीबग मोड
+
+सहयोगियों को ओपन इंटरप्रेटर की जांच करने में मदद करने के लिए, `--verbose` मोड अत्यधिक वर्बोस होता है।
+
+आप डीबग मोड को उसके फ़्लैग (`interpreter --verbose`) का उपयोग करके या चैट के बीच में सक्षम कर सकते हैं:
+
+```shell
+$ interpreter
+...
+> %verbose true <- डीबग मोड चालू करता है
+
+> %verbose false <- डीबग मोड बंद करता है
+```
+
+### इंटरैक्टिव मोड कमांड्स
+
+इंटरैक्टिव मोड में, आप निम्नलिखित कमांडों का उपयोग करके अपने अनुभव को बेहतर बना सकते हैं। यहां उपलब्ध कमांडों की सूची है:
+
+**उपलब्ध कमांड:**  
+ • `%verbose [true/false]`: डीबग मोड को टॉगल करें। कोई तर्क नहीं या 'true' के साथ, यह डीबग मोड में प्रवेश करता है। 'false' के साथ, यह डीबग मोड से बाहर निकलता है।  
+ • `%reset`: वर्तमान सत्र को रीसेट करता है।  
+ • `%undo`: पिछले संदेश और उसके जवाब को संदेश इतिहास से हटा देता है।  
+ • `%save_message [पथ]`: संदेशों को एक निर्दिष्ट JSON पथ पर सहेजता है। यदि कोई पथ निर्दिष्ट नहीं किया गया है, तो यह डिफ़ॉल्ट रूप से 'messages.json' पर जाता है।  
+ • `%load_message [पथ]`: एक निर्दिष्ट JSON पथ से संदेश लोड करता है। यदि कोई पथ निर्दिष्ट नहीं किया गया है, तो यह डिफ़ॉल्ट रूप से 'messages.json' पर जाता है।  
+ • `%help`: मदद संदेश दिखाएं।
+
+इन कमांडों का प्रयोग करके अपनी प्रतिक्रिया दें और हमें अपनी प्रतिक्रिया दें!
+
+## सुरक्षा सूचना
+
+क्योंकि उत्पन्न कोड आपके स्थानीय वातावरण में निष्पादित किया जाता है, इसलिए यह आपके फ़ाइलों और सिस्टम सेटिंग्स के साथ संवाद कर सकता है, जिससे अप्रत्याशित परिणाम जैसे डेटा हानि या सुरक्षा जोखिम हो सकता है।
+
+**⚠️ Open Interpreter कोड को निष्पादित करने से पहले उपयोगकर्ता की पुष्टि के लिए पूछेगा।**
+
+आप `interpreter -y` चला सकते हैं या ... ... `interpreter.auto_run = True` सेट कर सकते हैं ताकि इस पुष्टि को छोड़ दें, जिसके बाद:
+
+- फ़ाइलों या सिस्टम सेटिंग्स को संशोधित करने वाले कमांडों के लिए सतर्क रहें।
+- ओपन इंटरप्रेटर को एक स्व-चालित कार की तरह देखें और अपने टर्मिनल को बंद करके प्रक्रिया को समाप्त करने के लिए तत्पर रहें।
+- Google Colab या Replit जैसे प्रतिबंधित वातावरण में ओपन इंटरप्रेटर को चलाने का विचार करें। ये वातावरण अधिक संगठित होते हैं और अनियंत्रित कोड के साथ जुड़े जोखिमों को कम करते हैं।
+
+## यह कार्य कैसे करता है?
+
+Open Interpreter एक [फ़ंक्शन-कॉलिंग भाषा मॉडल](https://platform.openai.com/docs/guides/gpt/function-calling) को एक `exec()` फ़ंक्शन के साथ लैस करता है, जो एक `language` (जैसे "Python" या "JavaScript") और `code` को चलाने के लिए स्वीकार करता है।
+
+फिर हम मॉडल के संदेश, कोड और आपके सिस्टम के आउटपुट को टर्मिनल में मार्कडाउन के रूप में स्ट्रीम करते हैं।
+
+# योगदान
+
+योगदान करने के लिए आपकी रुचि के लिए धन्यवाद! हम समुदाय से सहभागिता का स्वागत करते हैं।
+
+अधिक जानकारी के लिए कृपया हमारे [योगदान दिशानिर्देश](CONTRIBUTING.md) देखें।
+
+## लाइसेंस
+
+Open Interpreter MIT लाइसेंस के तहत लाइसेंस है। आपको सॉफ़्टवेयर की प्रतिलिपि का उपयोग, प्रतिलिपि, संशोधन, वितरण, सबलाइसेंस और बेचने की अनुमति है।
+
+**ध्यान दें**: यह सॉफ़्टवेयर OpenAI से संबद्ध नहीं है।
+
+> अपनी उंगलियों की गति से काम करने वाले एक जूनियर प्रोग्रामर तक पहुंच ... नए वर्कफ़्लो को सरल और कुशल बना सकता है, साथ ही ... प्रोग्रामिंग के लाभों को नए दरबारों तक पहुंचा सकता है।
+>
+> — _OpenAI's Code Interpreter Release_
+
+<br>

open-interpreter/docs/README_JA.md

@@ -0,0 +1,398 @@
+<h1 align="center">● Open Interpreter</h1>
+
+<p align="center">
+    <a href="https://discord.gg/6p3fD6rBVm">
+        <img alt="Discord" src="https://img.shields.io/discord/1146610656779440188?logo=discord&style=flat&logoColor=white"/></a>
+    <a href="README_ES.md"> <img src="https://img.shields.io/badge/Español-white.svg" alt="ES doc"/></a>
+    <a href="../README.md"><img src="https://img.shields.io/badge/english-document-white.svg" alt="EN doc"></a>
+    <a href="README_ZH.md"><img src="https://img.shields.io/badge/文档-中文版-white.svg" alt="ZH doc"/></a>
+    <a href="README_IN.md"><img src="https://img.shields.io/badge/Hindi-white.svg" alt="IN doc"/></a>
+    <img src="https://img.shields.io/static/v1?label=license&message=AGPL&color=white&style=flat" alt="License"/>
+    <br>
+    <br>
+    <b>自然言語で指示するだけでコードを書いて実行までしてくれる。</b><br>
+    ローカルに実装したOpenAI Code Interpreterのオープンソース版。<br>
+    <br><a href="https://openinterpreter.com">デスクトップアプリへの早期アクセス</a>‎ ‎ |‎ ‎ <a href="https://docs.openinterpreter.com/">ドキュメント</a><br>
+</p>
+
+<br>
+
+![poster](https://github.com/KillianLucas/open-interpreter/assets/63927363/08f0d493-956b-4d49-982e-67d4b20c4b56)
+
+<br>
+
+**Update:** ● 0.1.12 アップデートで `interpreter --vision` 機能が導入されました。([ドキュメント](https://docs.openinterpreter.com/usage/terminal/vision))
+
+<br>
+
+```shell
+pip install open-interpreter
+```
+
+```shell
+interpreter
+```
+
+<br>
+
+**Open Interpreter**は、言語モデルに指示し、コード（Python、Javascript、Shell など）をローカル環境で実行できるようにします。インストール後、`$ interpreter` を実行するとターミナル経由で ChatGPT のようなインターフェースを介し、Open Interpreter とチャットができます。
+
+これにより、自然言語のインターフェースを通して、パソコンの一般的な機能が操作できます。
+
+- 写真、動画、PDF などの作成や編集
+- Chrome ブラウザの制御とリサーチ作業
+- 大規模なデータセットのプロット、クリーニング、分析
+- 等々
+
+**⚠️ 注意: 実行する前にコードを承認するよう求められます。**
+
+<br>
+
+## デモ
+
+https://github.com/KillianLucas/open-interpreter/assets/63927363/37152071-680d-4423-9af3-64836a6f7b60
+
+#### Google Colab でも対話形式のデモを利用できます:
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1WKmRXZgsErej2xUriKzxrEAXdxMSgWbb?usp=sharing)
+
+#### 音声インターフェースの実装例 (_Her_ からインスピレーションを得たもの):
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1NojYGHDgxH6Y1G1oxThEBBb2AtyODBIK)
+
+## クイックスタート
+
+```shell
+pip install open-interpreter
+```
+
+### ターミナル
+
+インストール後、`interpreter` を実行するだけです:
+
+```shell
+interpreter
+```
+
+### Python
+
+```python
+from interpreter import interpreter
+
+interpreter.chat("AAPLとMETAの株価グラフを描いてください") # コマンドを実行
+interpreter.chat() # 対話形式のチャットを開始
+```
+
+## ChatGPT の Code Interpreter との違い
+
+GPT-4 で実装された OpenAI の [Code Interpreter](https://openai.com/blog/chatgpt-plugins#code-interpreter) は、実世界のタスクを ChatGPT で操作できる素晴らしい機会を提供しています。
+
+しかし、OpenAI のサービスはホスティングされていてるクローズドな環境で、かなり制限がされています:
+
+- インターネットに接続できない。
+- [プリインストールされているパッケージが限られている](https://wfhbrian.com/mastering-chatgpts-code-interpreter-list-of-python-packages/)。
+- 最大アップロードは 100MB で、120 秒という実行時間の制限も。
+- 生成されたファイルやリンクとともに状態がリセットされる。
+
+---
+
+Open Interpreter は、ローカル環境で操作することで、これらの制限を克服しています。インターネットにフルアクセスでき、時間やファイルサイズの制限を受けず、どんなパッケージやライブラリも利用できます。
+
+Open Interpter は、GPT-4 Code Interpreter のパワーとローカル開発環境の柔軟性を組み合わせたものです。
+
+## コマンド
+
+**更新:** アップデート(0.1.5)でストリーミング機能が導入されました:
+
+```python
+message = "どのオペレーティングシステムを使用していますか？"
+
+for chunk in interpreter.chat(message, display=False, stream=True):
+  print(chunk)
+```
+
+### 対話型チャット
+
+ターミナルで対話形式のチャットを開始するには、コマ��ドラインから `interpreter` を実行します。
+
+```shell
+interpreter
+```
+
+または、.py ファイルから `interpreter.chat()` も利用できます。
+
+```python
+interpreter.chat()
+```
+
+**ストリーミングすることで chunk 毎に処理することも可能です:**
+
+```python
+message = "What operating system are we on?"
+
+for chunk in interpreter.chat(message, display=False, stream=True):
+  print(chunk)
+```
+
+### プログラム的なチャット
+
+より精確な制御のために、メッセージを直接`.chat(message)`に渡すことができます。
+
+```python
+interpreter.chat("/videos フォルダにあるすべての動画に字幕を追加する。")
+
+# ... ターミナルに出力をストリームし、タスクを完了 ...
+
+interpreter.chat("ついでに、字幕を大きくできますか？")
+
+# ...
+```
+
+### 新しいチャットを開始
+
+プログラム的チャットで Open Interpreter は、会話の履歴を記憶しています。新しくやり直したい場合は、リセットすることができます:
+
+```python
+interpreter.messages = []
+```
+
+### チャットの保存と復元
+
+`interpreter.chat()` はメッセージのリストを返し, `interpreter.messages = messages` のように使用することで会話を再開することが可能です:
+
+```python
+messages = interpreter.chat("私の名前は田中です。") # 'messages'にメッセージを保存
+interpreter.messages = [] # インタープリタをリセット（"田中"は忘れられる）
+
+interpreter.messages = messages # 'messages'からチャットを再開（"田中"は記憶される）
+```
+
+### システムメッセージのカスタマイズ
+
+Open Interpreter のシステムメッセージを確認し、設定することで、機能を拡張したり、権限を変更したり、またはより多くのコンテキストを与えたりすることができます。
+
+```python
+interpreter.system_message += """
+シェルコマンドを '-y' フラグ付きで実行し、ユーザーが確認する必要がないようにする。
+"""
+print(interpreter.system_message)
+```
+
+### モデルの変更
+
+Open Interpreter は、ホストされた言語モデルへの接続に [LiteLLM](https://docs.litellm.ai/docs/providers/) を使用しています。
+
+model パラメータを設定することで、モデルを変更することが可能です:
+
+```shell
+interpreter --model gpt-3.5-turbo
+interpreter --model claude-2
+interpreter --model command-nightly
+```
+
+Python では、オブジェクト上でモデルを設定します:
+
+```python
+interpreter.llm.model = "gpt-3.5-turbo"
+```
+
+[適切な "model" の値はこちらから検索してください。](https://docs.litellm.ai/docs/providers/)
+
+### ローカルのモデルを実行する
+
+Open Interpreter は、OpenAI 互換サーバーを使用してモデルをローカルで実行できます。 (LM Studio、jan.ai、ollam など)
+
+推論サーバーの api_base URL を指定して「interpreter」を実行するだけです (LM Studio の場合、デフォルトでは「http://localhost:1234/v1」です)。
+
+```shell
+interpreter --api_base "http://localhost:1234/v1" --api_key "fake_key"
+```
+
+あるいは、サードパーティのソフトウェアをインストールせずに、単に実行するだけで Llamafile を使用することもできます。
+
+```shell
+interpreter --local
+```
+
+より詳細なガイドについては、[Mike Bird によるこのビデオ](https://www.youtube.com/watch?v=CEs51hGWuGU?si=cN7f6QhfT4edfG5H) をご覧ください。
+
+**LM Studioをバックグラウンドで使用する方法**
+
+1. [https://lmstudio.ai/](https://lmstudio.ai/)からダウンロードして起動します。
+2. モデルを選択し、**↓ ダウンロード** をクリックします。
+3. 左側の **↔️** ボタン（💬 の下）をクリックします。
+4. 上部でモデルを選択し、**サーバーを起動** をクリックします。
+
+サーバーが稼働を開始したら、Open Interpreter との会話を開始できます。
+
+> **注意:** ローカルモードでは、`context_window` を 3000 に、`max_tokens` を 1000 に設定します。モデルによって異なる要件がある場合、これらのパラメータを手動で設定してください（下記参照）。
+
+#### コンテキストウィンドウ、最大トークン数
+
+ローカルで実行しているモデルの `max_tokens` と `context_window`（トークン単位）を変更することができます。
+
+ローカルモードでは、小さいコンテキストウィンドウは RAM を少なく使用するので、失敗する場合や遅い場合は、より短いウィンドウ（〜1000）を試すことをお勧めします。`max_tokens` が `context_window` より小さいことを確認してください。
+
+```shell
+interpreter --local --max_tokens 1000 --context_window 3000
+```
+
+### デバッグモード
+
+コントリビ��ーターが Open Interpreter を調査するのを助けるために、`--verbose` モードは非常に便利です。
+
+デバッグモードは、フラグ（`interpreter --verbose`）を使用するか、またはチャットの中から有効にできます:
+
+```shell
+$ interpreter
+...
+> %verbose true # <- デバッグモードを有効にする
+
+> %verbose false # <- デバッグモードを無効にする
+```
+
+### 対話モードのコマンド
+
+対話モードでは、以下のコマンドを使用して操作を便利にすることができます。利用可能なコマンドのリストは以下の通りです:
+
+**利用可能なコマンド:**
+
+- `%verbose [true/false]`: デバッグモードを切り替えます。引数なしまたは `true` でデバッグモードに入ります。`false` でデバッグモードを終了します。
+- `%reset`: 現在のセッションの会話をリセットします。
+- `%undo`: メッセージ履歴から前のユーザーメッセージと AI の応答を削除します。
+- `%save_message [path]`: メッセージを指定した JSON パスに保存します。パスが指定されていない場合、デフォルトは `messages.json` になります。
+- `%load_message [path]`: 指定した JSON パスからメッセージを読み込みます。パスが指定されていない場合、デフォルトは `messages.json` になります。
+- `%tokens [prompt]`: (_実験的_) 次のプロンプトのコンテキストとして送信されるトークンを計算し、そのコストを見積もります。オプションで、`prompt` が提供された場合のトークンと見積もりコストを計算します。見積もりコストは [LiteLLM の `cost_per_token()` メソッド](https://docs.litellm.ai/docs/completion/token_usage#2-cost_per_token)に依存します。
+- `%help`: ヘルプメッセージを表示します。
+
+### 設定
+
+Open Interpreter では、`config.yaml` ファイルを使用してデフォルトの動作を設定することができます。
+
+これにより、毎回コマンドライン引数を変更することなく柔軟に設定することができます。
+
+以下のコマンドを実行して設定ファイルを開きます:
+
+```
+interpreter --config
+```
+
+#### 設定ファイルの複数利用
+
+Open Interpreter は複数の `config.yaml` ファイルをサポートしており、`--config_file` 引数を通じて簡単に設定を切り替えることができます。
+
+**注意**: `--config_file` はファイル名またはファイルパスを受け入れます。ファイル名はデフォルトの設定ディレクトリを使用し、ファイルパスは指定されたパスを使用します。
+
+新しい設定を作成または編集するには、次のコマンドを実行します:
+
+```
+interpreter --config --config_file $config_path
+```
+
+特定の設定ファイルをロードして Open Interpreter を実行するには、次のコマンドを実行します:
+
+```
+interpreter --config_file $config_path
+```
+
+**注意**: `$config_path` をあなたの設定ファイルの名前またはパスに置き換えてください。
+
+##### 対話モードでの使用例
+
+1. 新しい `config.turbo.yaml` ファイルを作成します
+   ```
+   interpreter --config --config_file config.turbo.yaml
+   ```
+2. `config.turbo.yaml` ファイルを編集して、`model` を `gpt-3.5-turbo` に設定します
+3. `config.turbo.yaml` 設定で、Open Interpreter を実行します
+   ```
+   interpreter --config_file config.turbo.yaml
+   ```
+
+##### Python での使用例
+
+Python のスクリプトから Open Interpreter を呼び出すときにも設定ファイルをロードできます:
+
+```python
+import os
+from interpreter import interpreter
+
+currentPath = os.path.dirname(os.path.abspath(__file__))
+config_path=os.path.join(currentPath, './config.test.yaml')
+
+interpreter.extend_config(config_path=config_path)
+
+message = "What operating system are we on?"
+
+for chunk in interpreter.chat(message, display=False, stream=True):
+  print(chunk)
+```
+
+## FastAPI サーバーのサンプル
+
+アップデートにより Open Interpreter は、HTTP REST エンドポイントを介して制御できるようになりました:
+
+```python
+# server.py
+
+from fastapi import FastAPI
+from fastapi.responses import StreamingResponse
+from interpreter import interpreter
+
+app = FastAPI()
+
+@app.get("/chat")
+def chat_endpoint(message: str):
+    def event_stream():
+        for result in interpreter.chat(message, stream=True):
+            yield f"data: {result}\n\n"
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+@app.get("/history")
+def history_endpoint():
+    return interpreter.messages
+```
+
+```shell
+pip install fastapi uvicorn
+uvicorn server:app --reload
+```
+
+## 安全に関する注意
+
+生成されたコードはローカル環境で実行されるため、ファイルやシステム設定と相互作用��る可能性があり、データ損失やセキュリティリスクなど予期せぬ結果につながる可能性があります。
+
+**⚠️ Open Interpreter はコードを実行する前にユーザーの確認を求めます。**
+
+この確認を回避するには、`interpreter -y` を実行するか、`interpreter.auto_run = True` を設定します。その場合:
+
+- ファイルやシステム設定を変更するコマンドを要求するときは注意してください。
+- Open Interpreter を自動運転車のように監視し、ターミナルを閉じてプロセスを終了できるように準備しておいてください。
+- Google Colab や Replit のような制限された環境で Open Interpreter を実行することを検討してください。これらの環境はより隔離されており、任意のコードの実行に関連するリスクを軽減します。
+
+一部のリスクを軽減するための[セーフモード](docs/SAFE_MODE.md)と呼ばれる **実験的な** サポートがあります。
+
+## Open Interpreter はどのように機能するのか？
+
+Open Interpreter は、[関数が呼び出せる言語モデル](https://platform.openai.com/docs/guides/gpt/function-calling)に `exec()` 関数を装備し、実行する言語（"python"や"javascript"など）とコードが渡せるようになっています。
+
+そして、モデルからのメッセージ、コード、システムの出力を Markdown としてターミナルにストリーミングします。
+
+# 貢献
+
+貢献に興味を持っていただき、ありがとうございます！コミュニティからの参加を歓迎しています。
+
+詳しくは、[貢献ガイドライン](CONTRIBUTING.md)を参照してください。
+
+# ロードマップ
+
+Open Interpreter の未来を一足先に見るために、[私たちのロードマップ](https://github.com/KillianLucas/open-interpreter/blob/main/docs/ROADMAP.md)をご覧ください。
+
+**注意**: このソフトウェアは OpenAI とは関連していません。
+
+> あなたの指先のスピードで作業するジュニアプログラマーにアクセスすることで、… 新しいワークフローを楽で効率的なものにし、プログラミングの利点を新しいオーディエンスに開放することができます。
+>
+> — _OpenAI Code Interpreter リリース_
+
+<br>

open-interpreter/docs/README_VN.md

@@ -0,0 +1,395 @@
+<h1 align="center">● Open Interpreter</h1>
+
+<p align="center">
+    <a href="https://discord.gg/6p3fD6rBVm">
+        <img alt="Discord" src="https://img.shields.io/discord/1146610656779440188?logo=discord&style=flat&logoColor=white"/></a>
+    <a href="README_ES.md"> <img src="https://img.shields.io/badge/Español-white.svg" alt="ES doc"/></a>
+    <a href="docs/README_JA.md"><img src="https://img.shields.io/badge/ドキュメント-日本語-white.svg" alt="JA doc"/></a>
+    <a href="docs/README_ZH.md"><img src="https://img.shields.io/badge/文档-中文版-white.svg" alt="ZH doc"/></a>
+    <a href="docs/README_IN.md"><img src="https://img.shields.io/badge/Hindi-white.svg" alt="IN doc"/></a>
+    <img src="https://img.shields.io/static/v1?label=license&message=MIT&color=white&style=flat" alt="License"/>
+    <br>
+    <br>
+    <b>chạy mô hình ngôn ngữ trí tuệ nhân tạo trên máy tính của bạn.</b><br>
+    Mã nguồn mở và ứng dụng phát triển dựa trên code của OpenAI.<br>
+    <br><a href="https://openinterpreter.com">Quyền truy cập sớm dành cho máy tính cá nhân</a>‎ ‎ |‎ ‎ <b><a href="https://docs.openinterpreter.com/">Tài liệu đọc tham khảo</a></b><br>
+</p>
+
+<br>
+
+![poster](https://github.com/KillianLucas/open-interpreter/assets/63927363/08f0d493-956b-4d49-982e-67d4b20c4b56)
+
+<br>
+
+```shell
+pip install open-interpreter
+```
+
+```shell
+interpreter
+```
+
+<br>
+
+**Open Interpreter** Chạy LLMs trên máy tính cục bộ (Có thể sử dụng ngôn ngữ Python, Javascript, Shell, và nhiều hơn thế). Bạn có thể nói chuyện với Open Interpreter thông qua giao diện giống với ChatGPT ngay trên terminal của bạn bằng cách chạy lệnh `$ interpreter` sau khi tải thành công.
+
+Các tính năng chung giao diện ngôn ngữ mang llại
+
+- Tạo và chỉnh sửa ảnh, videos, PDF, vân vân...
+- Điều khiển trình duyệt Chrome để tiến hành nghiên cứu
+- Vẽ, làm sạch và phân tích các tập dữ liệu lớn (large datasets)
+- ...vân vân.
+
+**⚠️ Lưu ý: Bạn sẽ được yêu cầu phê duyệt mã trước khi chạy.**
+
+<br>
+
+## Thử nghiệm
+
+https://github.com/KillianLucas/open-interpreter/assets/63927363/37152071-680d-4423-9af3-64836a6f7b60
+
+#### Bản thử nghiệm có sẵn trên Google Colab:
+
+[![Mở trong Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1WKmRXZgsErej2xUriKzxrEAXdxMSgWbb?usp=sharing)
+
+#### Đi kèm với ứng dụng mẫu qua tương tác giọng nói (Lấy cảm hứng từ _Cô ấy_ (Giọng nữ)):
+
+[![Mở trong Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1NojYGHDgxH6Y1G1oxThEBBb2AtyODBIK)
+
+## Hướng dẫn khởi dộng ngắn
+
+```shell
+pip install open-interpreter
+```
+
+### Terminal
+
+Sau khi cài đặt, chạy dòng lệnh `interpreter`:
+
+```shell
+interpreter
+```
+
+### Python
+
+```python
+from interpreter import interpreter
+
+interpreter.chat("Vẽ giá cổ phiếu đã bình hoá của AAPL và META ") # Chạy trên 1 dòng lệnh
+interpreter.chat() # Khởi động chat có khả năng tương tác
+```
+
+## So sánh Code Interpreter của ChatGPT
+
+Bản phát hành của OpenAI [Code Interpreter](https://openai.com/blog/chatgpt-plugins#code-interpreter) sử dụng GPT-4 tăng khả năng hoàn thiện vấn đề thực tiễn với ChatGPT.
+
+Tuy nhiên, dịch vụ của OpenAI được lưu trữ, mã nguồn đóng, và rất hạn chế:
+
+- Không có truy cập Internet.
+- [Số lượng gói cài đặt hỗ trỡ có sẵn giới hạn](https://wfhbrian.com/mastering-chatgpts-code-interpreter-list-of-python-packages/).
+- tốc độ tải tối đa 100 MB , thời gian chạy giới hạn 120.0 giây .
+- Trạng thái tin nhắn bị xoá kèm với các tệp và liên kết được tạo trước đó khi đóng môi trường lại.
+
+---
+
+Open Interpreter khắc phục những hạn chế này bằng cách chạy cục bộ trobộ môi trường máy tính của bạn. Nó có toàn quyền truy cập vào Internet, không bị hạn chế về thời gian hoặc kích thước tệp và có thể sử dụng bất kỳ gói hoặc thư viện nào.
+
+Đây là sự kết hợp sức mạnh của mã nguồn của GPT-4 với tính linh hoạt của môi trường phát triển cục bộ của bạn.
+
+## Dòng lệnh
+
+**Update:** Cập nhật trình tạo lệnh (0.1.5) giới thiệu tính năng trực tuyến:
+
+```python
+message = "Chúng ta đang ở trên hệ điều hành nào?"
+
+for chunk in interpreter.chat(message, display=False, stream=True):
+  print(chunk)
+```
+
+### Trò chuyện tương tác
+
+Để tạo một cuộc trò chuyện tương tác từ terminal của bạn, chạy `interpreter` bằng dòng lệnh:
+
+```shell
+interpreter
+```
+
+hoặc `interpreter.chat()` từ file có đuôi .py :
+
+```python
+interpreter.chat()
+```
+
+**Bạn cũng có thể phát trực tuyến từng đoạn:**
+
+```python
+message = "Chúng ta đang chạy trên hệ điều hành nào?"
+
+for chunk in interpreter.chat(message, display=False, stream=True):
+  print(chunk)
+```
+
+### Trò chuyện lập trình được
+
+Để kiểm soát tốt hơn, bạn chuyển tin nhắn qua `.chat(message)`:
+
+```python
+interpreter.chat("Truyền phụ đề tới tất cả videos vào /videos.")
+
+# ... Truyền đầu ra đến thiết bị đầu cuối của bạn (terminal) hoàn thành tác vụ ...
+
+interpreter.chat("Nhìn đẹp đấy nhưng bạn có thể làm cho phụ đề lớn hơn được không?")
+
+# ...
+```
+
+### Tạo một cuộc trò chuyện mới:
+
+Trong Python, Open Interpreter ghi nhớ lịch sử hội thoại, nếu muốn bắt đầu lại từ đầu, bạn có thể cài thứ:
+
+```python
+interpreter.messages = []
+```
+
+### Lưu và khôi phục cuộc trò chuyện
+
+`interpreter.chat()` trả về danh sách tin nhắn, có thể được sử dụng để tiếp tục cuộc trò chuyện với `interpreter.messages = messages`:
+
+```python
+messages = interpreter.chat("Tên của tôi là Killian.") # Lưu tin nhắn tới 'messages'
+interpreter.messages = [] # Khởi động lại trình phiên dịch ("Killian" sẽ bị lãng quên)
+
+interpreter.messages = messages # Tiếp tục cuộc trò chuyện từ 'messages' ("Killian" sẽ được ghi nhớ)
+```
+
+### Cá nhân hoá tin nhắn từ hệ thống
+
+Bạn có thể kiếm tra và điều chỉnh tin nhắn hệ thống từ Optừ Interpreter để mở rộng chức năng của nó, thay đổi quyền, hoặc đưa cho nó nhiều ngữ cảnh hơn.
+
+```python
+interpreter.system_message += """
+Chạy shell commands với -y để người dùng không phải xác nhận chúng.
+"""
+print(interpreter.system_message)
+```
+
+### Thay đổi mô hình ngôn ngữ
+
+Open Interpreter sử dụng mô hình [LiteLLM](https://docs.litellm.ai/docs/providers/) để kết nối tới các mô hình ngôn ngữ được lưu trữ trước đó.
+
+Bạn có thể thay đổi mô hình ngôn ngữ bằng cách thay đổi tham số mô hình:
+
+```shell
+interpreter --model gpt-3.5-turbo
+interpreter --model claude-2
+interpreter --model command-nightly
+```
+
+Ở trong Python, đổi model bằng cách thay đổi đối tượng:
+
+```python
+interpreter.llm.model = "gpt-3.5-turbo"
+```
+
+[Tìm tên chuỗi "mô hình" phù hợp cho mô hình ngôn ngữ của bạn ở đây.](https://docs.litellm.ai/docs/providers/)
+
+### Chạy Open Interpreter trên máy cục bộ
+
+Open Interpreter có thể sử dụng máy chủ tương thích với OpenAI để chạy các mô hình cục bộ. (LM Studio, jan.ai, ollama, v.v.)
+
+Chỉ cần chạy `interpreter` với URL api_base của máy chủ suy luận của bạn (đối với LM studio, nó là `http://localhost:1234/v1` theo mặc định):
+
+``` vỏ
+trình thông dịch --api_base "http://localhost:1234/v1" --api_key "fake_key"
+```
+
+Ngoài ra, bạn có thể sử dụng Llamafile mà không cần cài đặt bất kỳ phần mềm bên thứ ba nào chỉ bằng cách chạy
+
+``` vỏ
+thông dịch viên --local
+```
+
+để biết hướng dẫn chi tiết hơn, hãy xem [video này của Mike Bird](https://www.youtube.com/watch?v=CEs51hGWuGU?si=cN7f6QhfT4edfG5H)
+
+**Để chạy LM Studio ở chế độ nền.**
+
+1. Tải [https://lmstudio.ai/](https://lmstudio.ai/) và khởi động.
+2. Chọn một mô hình rồi nhấn **↓ Download**.
+3. Nhấn vào nút **↔️** ở bên trái (dưới 💬).
+4. Chọn mô hình của bạn ở phía trên, rồi nhấn chạy **Start Server**.
+
+Một khi server chạy, bạn có thể bắt đầu trò chuyện với Open Interpreter.
+
+
+> **Lưu ý:** Chế độ cục bộ chỉnh `context_window` của bạn tới 3000, và `max_tokens` của bạn tới 600. Nếu mô hình của bạn có các yêu cầu khác, thì hãy chỉnh các tham số thủ công (xem bên dưới).
+
+#### Cửa sổ ngữ cảnh (Context Window), (Max Tokens)
+
+Bạn có thể thay đổi `max_tokens` và `context_window` (ở trong các) of locally running models.
+
+Ở chế độ cục bộ, các cửa sổ ngữ cảnh sẽ tiêu ít RAM hơn, vậy nên chúng tôi khuyến khích dùng cửa sổ nhỏ hơn (~1000) nếu như nó chạy không ổn định / hoặc nếu nó chậm. Đảm bảo rằng `max_tokens` ít hơn `context_window`.
+
+```shell
+interpreter --local --max_tokens 1000 --context_window 3000
+```
+
+### Chế độ sửa lỗi
+
+Để giúp đóng góp kiểm tra Open Interpreter, thì chế độ `--verbose` hơi dài dòng.
+
+Bạn có thể khởi động chế độ sửa lỗi bằng cách sử dụng cờ (`interpreter --verbose`), hoặc mid-chat:
+
+```shell
+$ interpreter
+...
+> %verbose true <- Khởi động chế độ gỡ lỗi
+
+> %verbose false <- Tắt chế độ gỡ lỗi
+```
+
+### Lệnh chế độ tương tác
+
+Trong chế độ tương tác, bạn có thể sử dụng những dòng lệnh sau để cải thiện trải nghiệm của mình. Đây là danh sách các dòng lệnh có sẵn:
+
+**Các lệnh có sẵn:**
+
+- `%verbose [true/false]`: Bật chế độ gỡ lỗi. Có hay không có `true` đều khởi động chế độ gỡ lỗi. Với `false` thì nó tắt chế độ gỡ lỗi.
+- `%reset`: Khởi động lại toàn bộ phiên trò chuyện hiện tại.
+- `%undo`: Xóa tin nhắn của người dùng trước đó và phản hồi của AI khỏi lịch sử tin nhắn.
+- `%save_message [path]`: Lưu tin nhắn vào một đường dẫn JSON được xác định từ trước. Nếu không có đường dẫn nào được cung cấp, nó sẽ mặc định là `messages.json`.
+- `%load_message [path]`: Tải tin nhắn từ một đường dẫn JSON được chỉ định. Nếu không có đường dẫn nào được cung cấp, nó sẽ mặc định là `messages.json`.
+- `%tokens [prompt]`: (_Experimental_) Tính toán các token sẽ được gửi cùng với lời nhắc tiếp theo dưới dạng ngữ cảnh và hao tổn. Tùy chọn tính toán token và hao tổn ước tính của một `prompt` nếu được cung cấp. Dựa vào [hàm `cost_per_token()` của mô hình LiteLLM](https://docs.litellm.ai/docs/completion/token_usage#2-cost_per_token) để tính toán hao tổn.
+- `%help`: Hiện lên trợ giúp cho cuộc trò chuyện.
+
+### Cấu hình cài
+
+Open Interpreter cho phép bạn thiết lập các tác vụ mặc định bằng cách sử dụng file `config.yaml`.
+
+Điều này cung cấp một cách linh hoạt để định cấu hình trình thông dịch mà không cần thay đổi đối số dòng lệnh mỗi lần
+
+Chạy lệnh sau để mở tệp cấu hình:
+
+```
+interpreter --config
+```
+
+#### Cấu hình cho nhiều tệp
+
+Open Interpreter hỗ trợ nhiều file `config.yaml`, cho phép bạn dễ dàng chuyển đổi giữa các cấu hình thông qua lệnh `--config_file`.
+
+**Chú ý**: `--config_file` chấp nhận tên tệp hoặc đường dẫn tệp. Tên tệp sẽ sử dụng thư mục cấu hình mặc định, trong khi đường dẫn tệp sẽ sử dụng đường dẫn đã chỉ định.
+
+Để tạo hoặc chỉnh sửa cấu hình mới, hãy chạy:
+
+```
+interpreter --config --config_file $config_path
+```
+
+Để yêu cầu Open Interpreter chạy một tệp cấu hình cụ thể, hãy chạy:
+
+```
+interpreter --config_file $config_path
+```
+
+**Chú ý**: Thay đổi `$config_path` với tên hoặc đường dẫn đến tệp cấu hình của bạn.
+
+##### Ví dụ CLI
+
+1. Tạo mới một file `config.turbo.yaml`
+   ```
+   interpreter --config --config_file config.turbo.yaml
+   ```
+2. Chạy file `config.turbo.yaml`để đặt lại `model` thành `gpt-3.5-turbo`
+3. Chạy Open Interpreter với cấu hình `config.turbo.yaml
+   ```
+   interpreter --config_file config.turbo.yaml
+   ```
+
+##### Ví dụ Python
+
+Bạn cũng có thể tải các tệp cấu hình khi gọi Open Interpreter từ tập lệnh Python:
+
+```python
+import os
+from interpreter import interpreter
+
+currentPath = os.path.dirname(os.path.abspath(__file__))
+config_path=os.path.join(currentPath, './config.test.yaml')
+
+interpreter.extend_config(config_path=config_path)
+
+message = "What operating system are we on?"
+
+for chunk in interpreter.chat(message, display=False, stream=True):
+  print(chunk)
+```
+
+## Máy chủ FastAPI mẫu
+
+Bản cập nhật trình tạo cho phép điều khiển Trình thông dịch mở thông qua các điểm cuối HTTP REST:
+
+```python
+# server.py
+
+from fastapi import FastAPI
+from fastapi.responses import StreamingResponse
+from interpreter import interpreter
+
+app = FastAPI()
+
+@app.get("/chat")
+def chat_endpoint(message: str):
+    def event_stream():
+        for result in interpreter.chat(message, stream=True):
+            yield f"data: {result}\n\n"
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+@app.get("/history")
+def history_endpoint():
+    return interpreter.messages
+```
+
+```shell
+pip install fastapi uvicorn
+uvicorn server:app --reload
+```
+
+## Hướng dẫn an toàn
+
+Vì mã được tạo được thực thi trong môi trường cục bộ của bạn nên nó có thể tương tác với các tệp và cài đặt hệ thống của bạn, có khả năng dẫn đến các kết quả không mong muốn như mất dữ liệu hoặc rủi ro bảo mật.
+
+**⚠️ Open Interpreter sẽ yêu cầu xác nhận của người dùng trước khi chạy code.**
+
+Bạn có thể chạy `interpreter -y` hoặc đặt `interpreter.auto_run = True` để bỏ qua xác nhận này, trong trường hợp đó:
+
+- Hãy thận trọng khi yêu cầu các lệnh sửa đổi tệp hoặc cài đặt hệ thống.
+- Theo dõi Open Interpreter giống như một chiếc ô tô tự lái và sẵn sàng kết thúc quá trình bằng cách đóng terminal của bạn.
+- Cân nhắc việc chạy Open Interpreter trong môi trường bị hạn chế như Google Colab hoặc Replit. Những môi trường này biệt lập hơn, giảm thiểu rủi ro khi chạy code tùy ý.
+
+Đây là hỗ trợ **thử nghiệm** cho [chế độ an toàn](docs/SAFE_MODE.md) giúp giảm thiểu rủi ro.
+
+## Nó hoạt động thế nào?
+
+Open Interpreter trang bị [mô hình ngôn ngữ gọi hàm](https://platform.openai.com/docs/guides/gpt/function-calling) với một hàm `exec()`, chấp nhận một `language` (như "Python" hoặc "JavaScript") và `code` để chạy.
+
+Sau đó, chúng tôi truyền trực tuyến thông báo, mã của mô hình và kết quả đầu ra của hệ thống của bạn đến terminal dưới dạng Markdown.
+
+# Đóng góp
+
+Cảm ơn bạn đã quan tâm đóng góp! Chúng tôi hoan nghênh sự tham gia của cộng đồng.
+
+Vui lòng xem [Hướng dẫn đóng góp](CONTRIBUTING.md) để biết thêm chi tiết cách tham gia.
+
+## Giấy phép
+
+Open Interpreter được cấp phép theo Giấy phép MIT. Bạn được phép sử dụng, sao chép, sửa đổi, phân phối, cấp phép lại và bán các bản sao của phần mềm.
+
+**Lưu ý**: Phần mềm này không liên kết với OpenAI.
+
+> Có quyền truy cập vào một lập trình viên cấp dưới làm việc nhanh chóng trong tầm tay bạn ... có thể khiến quy trình làm việc mới trở nên dễ dàng và hiệu quả, cũng như mở ra những lợi ích của việc lập trình cho người mới.
+>
+> — _Phát hành trình thông dịch mã của OpenAI_
+
+<br>

open-interpreter/docs/README_ZH.md

@@ -0,0 +1,220 @@
+<h1 align="center">● Open Interpreter（开放解释器）</h1>
+
+<p align="center">
+    <a href="https://discord.gg/6p3fD6rBVm"><img alt="Discord" src="https://img.shields.io/discord/1146610656779440188?logo=discord&style=flat&logoColor=white"></a>
+    <a href="README_JA.md"><img src="https://img.shields.io/badge/ドキュメント-日本語-white.svg" alt="JA doc"></a>
+    <a href="README_IN.md"><img src="https://img.shields.io/badge/Hindi-white.svg" alt="IN doc"/></a>
+    <a href="README_ES.md"> <img src="https://img.shields.io/badge/Español-white.svg" alt="ES doc"/></a>
+    <a href="../README.md"><img src="https://img.shields.io/badge/english-document-white.svg" alt="EN doc"></a>
+    <a href="https://github.com/OpenInterpreter/open-interpreter/blob/main/LICENSE"><img src="https://img.shields.io/static/v1?label=license&message=AGPL&color=white&style=flat" alt="License"></a>
+    <br>
+    <br>
+    <b>让语言模型在您的计算机上运行代码。</b><br>
+    在本地实现的开源OpenAI的代码解释器。<br>
+    <br><a href="https://openinterpreter.com">登记以提前获取Open Interpreter（开放解释器）桌面应用程序</a>‎ ‎ |‎ ‎ <b><a href="https://docs.openinterpreter.com/">阅读新文档</a></b><br>
+</p>
+
+<br>
+
+![poster](https://github.com/KillianLucas/open-interpreter/assets/63927363/08f0d493-956b-4d49-982e-67d4b20c4b56)
+
+<br>
+
+```shell
+pip install open-interpreter
+```
+
+```shell
+interpreter
+```
+
+<br>
+
+**Open Interpreter（开放解释器）** 可以让大语言模型（LLMs）在本地运行代码（比如 Python、JavaScript、Shell 等）。安装后，在终端上运行 `$ interpreter` 即可通过类似 ChatGPT 的界面与 Open Interpreter 聊天。
+
+本软件为计算机的通用功能提供了一个自然语言界面，比如：
+
+- 创建和编辑照片、视频、PDF 等
+- 控制 Chrome 浏览器进行搜索
+- 绘制、清理和分析大型数据集
+- ...
+
+**⚠️ 注意：在代码运行前都会要求您批准执行代码。**
+
+<br>
+
+## 演示
+
+https://github.com/KillianLucas/open-interpreter/assets/63927363/37152071-680d-4423-9af3-64836a6f7b60
+
+#### Google Colab 上也提供了交互式演示：
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1WKmRXZgsErej2xUriKzxrEAXdxMSgWbb?usp=sharing)
+
+## 快速开始
+
+```shell
+pip install open-interpreter
+```
+
+### 终端
+
+安装后，运行 `interpreter`：
+
+```shell
+interpreter
+```
+
+### Python
+
+```python
+from interpreter import interpreter
+
+interpreter.chat("Plot AAPL and META's normalized stock prices") # 执行单一命令
+interpreter.chat() # 开始交互式聊天
+```
+
+## 与 ChatGPT 的代码解释器比较
+
+OpenAI 发布的 [Code Interpreter](https://openai.com/blog/chatgpt-plugins#code-interpreter) 和 GPT-4 提供了一个与 ChatGPT 完成实际任务的绝佳机会。
+
+但是，OpenAI 的服务是托管的，闭源的，并且受到严格限制：
+
+- 无法访问互联网。
+- [预装软件包数量有限](https://wfhbrian.com/mastering-chatgpts-code-interpreter-list-of-python-packages/)。
+- 允许的最大上传为 100 MB，且最大运行时间限制为 120.0 秒
+- 当运行环境中途结束时，之前的状态会被清除（包括任何生成的文件或链接）。
+
+---
+
+Open Interpreter（开放解释器）通过在本地环境中运行克服了这些限制。它可以完全访问互联网，不受运行时间或是文件大小的限制，也可以使用任何软件包或库。
+
+它将 GPT-4 代码解释器的强大功能与本地开发环境的灵活性相结合。
+
+## 命令
+
+### 交互式聊天
+
+要在终端中开始交互式聊天，从命令行运行 `interpreter`：
+
+```shell
+interpreter
+```
+
+或者从.py 文件中运行 `interpreter.chat()`：
+
+```python
+interpreter.chat()
+```
+
+### 程序化聊天
+
+为了更精确的控制，您可以通过 `.chat(message)` 直接传递消息 ：
+
+```python
+interpreter.chat("Add subtitles to all videos in /videos.")
+
+# ... Streams output to your terminal, completes task ...
+
+interpreter.chat("These look great but can you make the subtitles bigger?")
+
+# ...
+```
+
+### 开始新的聊天
+
+在 Python 中，Open Interpreter 会记录历史对话。如果你想从头开始，可以进行重置：
+
+```python
+interpreter.messages = []
+```
+
+### 保存和恢复聊天
+
+```python
+messages = interpreter.chat("My name is Killian.") # 保存消息到 'messages'
+interpreter.messages = [] # 重置解释器 ("Killian" 将被遗忘)
+
+interpreter.messages = messages # 从 'messages' 恢复聊天 ("Killian" 将被记住)
+```
+
+### 自定义系统消息
+
+你可以检查和配置 Open Interpreter 的系统信息，以扩展其功能、修改权限或赋予其更多上下文。
+
+```python
+interpreter.system_message += """
+使用 -y 运行 shell 命令，这样用户就不必确认它们。
+"""
+print(interpreter.system_message)
+```
+
+### 更改模型
+
+Open Interpreter ��用[LiteLLM](https://docs.litellm.ai/docs/providers/)连接到语言模型。
+
+您可以通过设置模型参数来更改模型：
+
+```shell
+interpreter --model gpt-3.5-turbo
+interpreter --model claude-2
+interpreter --model command-nightly
+```
+
+在 Python 环境下，您需要手动设置模型：
+
+```python
+interpreter.llm.model = "gpt-3.5-turbo"
+```
+
+### 在本地运行 Open Interpreter（开放解释器）
+
+```shell
+interpreter --local
+```
+
+### 调试模式
+
+为了帮助贡献者检查和调试 Open Interpreter，`--verbose` 模式提供了详细的日志。
+
+您可以使用 `interpreter --verbose` 来激活调试模式，或者直接在终端输入：
+
+```shell
+$ interpreter
+...
+> %verbose true <- 开启调试模式
+
+> %verbose false <- 关闭调试模式
+```
+
+## 安全提示
+
+由于生成的代码是在本地环境中运行的，因此会与文件和系统设置发生交互，从而可能导致本地数据丢失或安全风险等意想不到的结果。
+
+**⚠️ 所以在执行任何代码之前，Open Interpreter 都会询问用户是否运行。**
+
+您可以运行 `interpreter -y` 或设置 `interpreter.auto_run = True` 来绕过此确认，此时：
+
+- 在运行请求修改本地文件或系统设置的命令时要谨慎。
+- 请像驾驶自动驾驶汽车一直握着方向盘一样留意 Open Interpreter，并随时做好通过关闭终端来结束进程的准备。
+- 考虑在 Google Colab 或 Replit 等受限环境中运行 Open Interpreter 的主要原因是这些环境更加独立，从而降低执行任意代码导致出现问题的风险。
+
+## 它是如何工作的？
+
+Open Interpreter 为[函数调用语言模型](https://platform.openai.com/docs/guides/gpt/function-calling)配备了 `exec()` 函数，该函数接受 `编程语言`（如 "Python "或 "JavaScript"）和要运行的 `代码`。
+
+然后，它会将模型的信息、代码和系统的输出以 Markdown 的形式流式传输到终端。
+
+# 作出贡献
+
+感谢您对本项目参与的贡献！我们欢迎所有人贡献到本项目里面。
+
+请参阅我们的 [贡献准则](CONTRIBUTING.md)，了解如何参与贡献的更多详情。
+
+## 规划图
+
+若要预览 Open Interpreter 的未来，请查看[我们的路线图](https://github.com/KillianLucas/open-interpreter/blob/main/docs/ROADMAP.md) 。
+
+**请注意**：此软件与 OpenAI 无关。
+
+![thumbnail-ncu](https://github.com/KillianLucas/open-interpreter/assets/63927363/1b19a5db-b486-41fd-a7a1-fe2028031686)

open-interpreter/docs/ROADMAP.md

@@ -0,0 +1,168 @@
+# Roadmap
+
+## Documentation
+- [ ] Work with Mintlify to translate docs. How does Mintlify let us translate our documentation automatically? I know there's a way.
+- [ ] Better comments throughout the package (they're like docs for contributors)
+- [ ] Show how to replace interpreter.llm so you can use a custom llm
+
+## New features
+- [ ] Figure out how to get OI to answer to user input requests like python's `input()`. Do we somehow detect a delay in the output..? Is there some universal flag that TUIs emit when they expect user input? Should we do this semantically with embeddings, then ask OI to review it and respond..?
+- [ ] Placeholder text that gives a compelling example OI request. Probably use `textual`
+- [ ] Everything else `textual` offers, like could we make it easier to select text? Copy paste in and out? Code editing interface?
+- [ ] Let people edit the code OI writes. Could just open it in the user's preferred editor. Simple. [Full description of how to implement this here.](https://github.com/KillianLucas/open-interpreter/pull/830#issuecomment-1854989795)
+- [ ] Display images in the terminal interface
+- [ ] There should be a function that just renders messages to the terminal, so we can revive conversation navigator, and let people look at their conversations
+- [ ] ^ This function should also render the last like 5 messages once input() is about to be run, so we don't get those weird stuttering `rich` artifacts
+- [ ] Let OI use OI, add `interpreter.chat(async=True)` bool. OI can use this to open OI on a new thread
+  - [ ] Also add `interpreter.await()` which waits for `interpreter.running` (?) to = False, and `interpreter.result()` which returns the last assistant messages content.
+- [ ] Allow for limited functions (`interpreter.functions`) using regex
+  - [ ] If `interpreter.functions != []`:
+    - [ ] set `interpreter.computer.languages` to only use Python
+    - [ ] Use regex to ensure the output of code blocks conforms to just using those functions + other python basics
+- [ ] (Maybe) Allow for a custom embedding function (`interpreter.embed` or `computer.ai.embed`) which will let us do semantic search
+- [ ] (Maybe) if a git is detected, switch to a mode that's good for developers, like showing nested file structure in dynamic system message, searching for relevant functions (use computer.files.search)
+- [x] Allow for integrations somehow (you can replace interpreter.llm.completions with a wrapped completions endpoint for any kind of logging. need to document this tho)
+  - [ ] Document this^
+- [ ] Expand "safe mode" to have proper, simple Docker support, or maybe Cosmopolitan LibC
+- [ ] Make it so core can be run elsewhere from terminal package — perhaps split over HTTP (this would make docker easier too)
+- [ ] For OS mode, experiment with screenshot just returning active window, experiment with it just showing the changes, or showing changes in addition to the whole thing, etc. GAIA should be your guide
+
+## Future-proofing
+
+- [ ] Really good tests / optimization framework, to be run less frequently than Github actions tests
+  - [x] Figure out how to run us on [GAIA](https://huggingface.co/gaia-benchmark)
+    - [x] How do we just get the questions out of this thing?
+    - [x] How do we assess whether or not OI has solved the task?
+  - [ ] Loop over GAIA, use a different language model every time (use Replicate, then ask LiteLLM how they made their "mega key" to many different LLM providers)
+  - [ ] Loop over that ↑ using a different prompt each time. Which prompt is best across all LLMs?
+  - [ ] (For the NCU) might be good to use a Google VM with a display
+  - [ ] (Future future) Use GPT-4 to assess each result, explaining each failure. Summarize. Send it all to GPT-4 + our prompt. Let it redesign the prompt, given the failures, rinse and repeat
+- [ ] Stateless (as in, doesn't use the application directory) core python package. All `appdir` or `platformdirs` stuff should be only for the TUI
+  - [ ] `interpreter.__dict__` = a dict derived from config is how the python package should be set, and this should be from the TUI. `interpreter` should not know about the config
+  - [ ] Move conversation storage out of the core and into the TUI. When we exit or error, save messages same as core currently does
+- [ ] Further split TUI from core (some utils still reach across)
+- [ ] Better storage of different model keys in TUI / config file. All keys, to multiple providers, should be stored in there. Easy switching
+  - [ ] Automatically migrate users from old config to new config, display a message of this
+- [ ] On update, check for new system message and ask user to overwrite theirs, or only let users pass in "custom instructions" which adds to our system message
+  - [ ] I think we could have a config that's like... system_message_version. If system_message_version is below the current version, ask the user if we can overwrite it with the default config system message of that version. (This somewhat exists now but needs to be robust)
+
+# What's in our scope?
+
+Open Interpreter contains two projects which support each other, whose scopes are as follows:
+
+1. `core`, which is dedicated to figuring out how to get LLMs to safely control a computer. Right now, this means creating a real-time code execution environment that language models can operate.
+2. `terminal_interface`, a text-only way for users to direct the code-running LLM running inside `core`. This includes functions for connecting the `core` to various local and hosted LLMs (which the `core` itself should not know about).
+
+# What's not in our scope?
+
+Our guiding philosophy is minimalism, so we have also decided to explicitly consider the following as **out of scope**:
+
+1. Additional functions in `core` beyond running code.
+2. More complex interactions with the LLM in `terminal_interface` beyond text (but file paths to more complex inputs, like images or video, can be included in that text).
+
+---
+
+This roadmap gets pretty rough from here. More like working notes.
+
+# Working Notes
+
+## \* Roughly, how to build `computer.browser`:
+
+First I think we should have a part, like `computer.browser.ask(query)` which just hits up [perplexity](https://www.perplexity.ai/) for fast answers to questions.
+
+Then we want these sorts of things:
+
+- `browser.open(url)`
+- `browser.screenshot()`
+- `browser.click()`
+
+It should actually be based closely on Selenium. Copy their API so the LLM knows it.
+
+Other than that, basically should be = to the computer module itself, at least the IO / keyboard and mouse parts.
+
+However, for non vision models, `browser.screenshot()` can return the accessibility tree, not an image. And for `browser.click(some text)` we can use the HTML to find that text.
+
+**Here's how GPT suggests we implement the first steps of this:**
+
+Creating a Python script that automates the opening of Chrome with the necessary flags and then interacts with it to navigate to a URL and retrieve the accessibility tree involves a few steps. Here's a comprehensive approach:
+
+1. **Script to Launch Chrome with Remote Debugging**:
+
+   - This script will start Chrome with the `--remote-debugging-port=9222` flag.
+   - It will handle different platforms (Windows, macOS, Linux).
+
+2. **Python Script for Automation**:
+   - This script uses `pychrome` to connect to the Chrome instance, navigate to a URL, and retrieve the accessibility tree.
+
+### Step 1: Launching Chrome with Remote Debugging
+
+You'll need a script to launch Chrome. This script varies based on the operating system. Below is an example for Windows. You can adapt it for macOS or Linux by changing the path and command to start Chrome.
+
+```python
+import subprocess
+import sys
+import os
+
+def launch_chrome():
+    chrome_path = "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"  # Update this path for your system
+    url = "http://localhost:9222/json/version"
+    subprocess.Popen([chrome_path, '--remote-debugging-port=9222'], shell=True)
+    print("Chrome launched with remote debugging on port 9222.")
+
+if __name__ == "__main__":
+    launch_chrome()
+```
+
+### Step 2: Python Script to Navigate and Retrieve Accessibility Tree
+
+Next, you'll use `pychrome` to connect to this Chrome instance. Ensure you've installed `pychrome`:
+
+```bash
+pip install pychrome
+```
+
+Here's the Python script:
+
+```python
+import pychrome
+import time
+
+def get_accessibility_tree(tab):
+    # Enable the Accessibility domain
+    tab.call_method("Accessibility.enable")
+
+    # Get the accessibility tree
+    tree = tab.call_method("Accessibility.getFullAXTree")
+    return tree
+
+def main():
+    # Create a browser instance
+    browser = pychrome.Browser(url="http://127.0.0.1:9222")
+
+    # Create a new tab
+    tab = browser.new_tab()
+
+    # Start the tab
+    tab.start()
+
+    # Navigate to a URL
+    tab.set_url("https://www.example.com")
+    time.sleep(3)  # Wait for page to load
+
+    # Retrieve the accessibility tree
+    accessibility_tree = get_accessibility_tree(tab)
+    print(accessibility_tree)
+
+    # Stop the tab (closes it)
+    tab.stop()
+
+    # Close the browser
+    browser.close()
+
+if __name__ == "__main__":
+    main()
+```
+
+This script will launch Chrome, connect to it, navigate to "https://www.example.com", and then print the accessibility tree to the console.
+
+**Note**: The script to launch Chrome assumes a typical installation path on Windows. You will need to modify this path according to your Chrome installation location and operating system. Additionally, handling different operating systems requires conditional checks and respective commands for each OS.

open-interpreter/docs/SAFE_MODE.md

@@ -0,0 +1,60 @@
+# Safe Mode
+
+**⚠️ Safe mode is experimental and does not provide any guarantees of safety or security.**
+
+Open Interpreter is working on providing an experimental safety toolkit to help you feel more confident running the code generated by Open Interpreter.
+
+Install Open Interpreter with the safety toolkit dependencies as part of the bundle:
+
+```shell
+pip install open-interpreter[safe]
+```
+
+Alternatively, you can install the safety toolkit dependencies separately in your virtual environment:
+
+```shell
+pip install semgrep
+```
+
+## Features
+
+- **No Auto Run**: Safe mode disables the ability to automatically execute code
+- **Code Scanning**: Scan generated code for vulnerabilities with [`semgrep`](https://semgrep.dev/)
+
+## Enabling Safe Mode
+
+You can enable safe mode by passing the `--safe` flag when invoking `interpreter` or by configuring `safe_mode` in your [config file](https://github.com/KillianLucas/open-interpreter#configuration).
+
+The safe mode setting has three options:
+
+- `off`: disables the safety toolkit (_default_)
+- `ask`: prompts you to confirm that you want to scan code
+- `auto`: automatically scans code
+
+### Example Config:
+
+```yaml
+model: gpt-4
+temperature: 0
+verbose: false
+safe_mode: ask
+```
+
+## Roadmap
+
+Some upcoming features that enable even more safety:
+
+- [Execute code in containers](https://github.com/KillianLucas/open-interpreter/pull/459)
+
+## Tips & Tricks
+
+You can adjust the `system_message` in your [config file](https://github.com/KillianLucas/open-interpreter#configuration) to include instructions for the model to scan packages with [`guarddog`]() before installing them.
+
+```yaml
+model: gpt-4
+verbose: false
+safe_mode: ask
+system_message: |
+  # normal system message here
+  BEFORE INSTALLING ANY PACKAGES WITH pip OR npm YOU MUST SCAN THEM WITH `guarddog` FIRST. Run `guarddog pypi scan $package` for pip packages and `guarddog npm scan $package` for npm packages. `guarddog` only accepts one package name at a time.
+```

open-interpreter/docs/SECURITY.md

@@ -0,0 +1,38 @@
+# Open Interpreter Security Policy
+
+We take security seriously. Responsible reporting and disclosure of security
+vulnerabilities is important for the protection and privacy of our users. If you
+discover any security vulnerabilities, please follow these guidelines.
+
+Published security advisories are available on our [GitHub Security Advisories]
+page.
+
+To report a vulnerability, please draft a [new security advisory on GitHub]. Any
+fields that you are unsure of or don't understand can be left at their default
+values. The important part is that the vulnerability is reported. Once the
+security advisory draft has been created, we will validate the vulnerability and
+coordinate with you to fix it, release a patch, and responsibly disclose the
+vulnerability to the public. Read GitHub's documentation on [privately reporting
+a security vulnerability] for details.
+
+Please do not report undisclosed vulnerabilities on public sites or forums,
+including GitHub issues and pull requests. Reporting vulnerabilities to the
+public could allow attackers to exploit vulnerable applications before we have
+been able to release a patch and before applications have had time to install
+the patch. Once we have released a patch and sufficient time has passed for
+applications to install the patch, we will disclose the vulnerability to the
+public, at which time you will be free to publish details of the vulnerability
+on public sites and forums.
+
+If you have a fix for a security vulnerability, please do not submit a GitHub
+pull request. Instead, report the vulnerability as described in this policy.
+Once we have verified the vulnerability, we can create a [temporary private
+fork] to collaborate on a patch.
+
+We appreciate your cooperation in helping keep our users safe by following this
+policy.
+
+[github security advisories]: https://github.com/KillianLucas/open-interpreter/security/advisories
+[new security advisory on github]: https://github.com/KillianLucas/open-interpreter/security/advisories/new
+[privately reporting a security vulnerability]: https://docs.github.com/en/code-security/security-advisories/guidance-on-reporting-and-writing/privately-reporting-a-security-vulnerability
+[temporary private fork]: https://docs.github.com/en/code-security/security-advisories/repository-security-advisories/collaborating-in-a-temporary-private-fork-to-resolve-a-repository-security-vulnerability

open-interpreter/docs/code-execution/computer-api.mdx

@@ -0,0 +1,240 @@
+---
+title: Computer API
+---
+
+The following functions are designed for language models to use in Open Interpreter, currently only supported in [OS Mode](/guides/os-mode/).
+
+### Display - View
+
+Takes a screenshot of the primary display.
+
+
+
+```python
+interpreter.computer.display.view()
+```
+
+
+
+### Display - Center
+
+Gets the x, y value of the center of the screen.
+
+
+
+```python
+x, y = interpreter.computer.display.center()
+```
+
+
+
+### Keyboard - Hotkey
+
+Performs a hotkey on the computer
+
+
+
+```python
+interpreter.computer.keboard.hotkey(" ", "command")
+```
+
+
+
+### Keyboard - Write
+
+Writes the text into the currently focused window.
+
+
+
+```python
+interpreter.computer.keyboard.write("hello")
+```
+
+
+
+### Mouse - Click
+
+Clicks on the specified coordinates, or an icon, or text. If text is specified, OCR will be run on the screenshot to find the text coordinates and click on it.
+
+
+
+```python
+# Click on coordinates
+interpreter.computer.mouse.click(x=100, y=100)
+
+# Click on text on the screen
+interpreter.computer.mouse.click("Onscreen Text")
+
+# Click on a gear icon
+interpreter.computer.mouse.click(icon="gear icon")
+```
+
+
+
+### Mouse - Move
+
+Moves to the specified coordinates, or an icon, or text. If text is specified, OCR will be run on the screenshot to find the text coordinates and move to it.
+
+
+
+```python
+# Click on coordinates
+interpreter.computer.mouse.move(x=100, y=100)
+
+# Click on text on the screen
+interpreter.computer.mouse.move("Onscreen Text")
+
+# Click on a gear icon
+interpreter.computer.mouse.move(icon="gear icon")
+```
+
+
+
+### Mouse - Scroll
+
+Scrolls the mouse a specified number of pixels.
+
+
+
+```python
+# Scroll Down
+interpreter.computer.mouse.scroll(-10)
+
+# Scroll Up
+interpreter.computer.mouse.scroll(10)
+```
+
+
+
+### Clipboard - View
+
+Returns the contents of the clipboard.
+
+
+
+```python
+interpreter.computer.clipboard.view()
+```
+
+
+
+### OS - Get Selected Text
+
+Get the selected text on the screen.
+
+
+
+```python
+interpreter.computer.os.get_selected_text()
+```
+
+
+
+### Mail - Get
+
+Retrieves the last `number` emails from the inbox, optionally filtering for only unread emails. (Mac only)
+
+
+
+```python
+interpreter.computer.mail.get(number=10, unread=True)
+```
+
+
+
+### Mail - Send
+
+Sends an email with the given parameters using the default mail app. (Mac only)
+
+
+
+```python
+interpreter.computer.mail.send("john@email.com", "Subject", "Body", ["path/to/attachment.pdf", "path/to/attachment2.pdf"])
+```
+
+
+
+### Mail - Unread Count
+
+Retrieves the count of unread emails in the inbox. (Mac only)
+
+
+
+```python
+interpreter.computer.mail.unread_count()
+```
+
+
+
+### SMS - Send
+
+Send a text message using the default SMS app. (Mac only)
+
+
+
+```python
+interpreter.computer.sms.send("2068675309", "Hello from Open Interpreter!")
+```
+
+
+
+### Contacts - Get Phone Number
+
+Returns the phone number of a contact name. (Mac only)
+
+
+
+```python
+interpreter.computer.contacts.get_phone_number("John Doe")
+```
+
+
+
+### Contacts - Get Email Address
+
+Returns the email of a contact name. (Mac only)
+
+
+
+```python
+interpreter.computer.contacts.get_phone_number("John Doe")
+```
+
+
+
+### Calendar - Get Events
+
+Fetches calendar events for the given date or date range from all calendars. (Mac only)
+
+
+
+```python
+interpreter.computer.calendar.get_events(start_date=datetime, end_date=datetime)
+```
+
+
+
+### Calendar - Create Event
+
+Creates a new calendar event. Uses first calendar if none is specified (Mac only)
+
+
+
+```python
+interpreter.computer.calendar.create_event(title="Title", start_date=datetime, end_date=datetime, location="Location", notes="Notes", calendar="Work")
+```
+
+
+
+### Calendar - Delete Event
+
+Delete a specific calendar event. (Mac only)
+
+
+
+```python
+interpreter.computer.calendar.delete_event(event_title="Title", start_date=datetime, calendar="Work")
+```
+
+
+

open-interpreter/docs/code-execution/custom-languages.mdx

@@ -0,0 +1,76 @@
+---
+title: Custom Languages
+---
+
+You can add or edit the programming languages that Open Interpreter's computer runs.
+
+In this example, we'll swap out the `python` language for a version of `python` that runs in the cloud. We'll use `E2B` to do this.
+
+([`E2B`](https://e2b.dev/) is a secure, sandboxed environment where you can run arbitrary code.)
+
+First, [get an API key here](https://e2b.dev/), and set it:
+
+```python
+import os
+os.environ["E2B_API_KEY"] = "<your_api_key_here>"
+```
+
+Then, define a custom language for Open Interpreter. The class name doesn't matter, but we'll call it `PythonE2B`:
+
+```python
+import e2b
+
+class PythonE2B:
+    """
+    This class contains all requirements for being a custom language in Open Interpreter:
+
+    - name (an attribute)
+    - run (a method)
+    - stop (a method)
+    - terminate (a method)
+
+    You can use this class to run any language you know how to run, or edit any of the official languages (which also conform to this class).
+
+    Here, we'll use E2B to power the `run` method.
+    """
+
+    # This is the name that will appear to the LLM.
+    name = "python"
+
+    # Optionally, you can append some information about this language to the system message:
+    system_message = "# Follow this rule: Every Python code block MUST contain at least one print statement."
+
+    # (E2B isn't a Jupyter Notebook, so we added ^ this so it would print things,
+    # instead of putting variables at the end of code blocks, which is a Jupyter thing.)
+
+    def run(self, code):
+        """Generator that yields a dictionary in LMC Format."""
+
+        # Run the code on E2B
+        stdout, stderr = e2b.run_code('Python3', code)
+
+        # Yield the output
+        yield {
+            "type": "console", "format": "output",
+            "content": stdout + stderr # We combined these arbitrarily. Yield anything you'd like!
+        }
+
+    def stop(self):
+        """Stops the code."""
+        # Not needed here, because e2b.run_code isn't stateful.
+        pass
+
+    def terminate(self):
+        """Terminates the entire process."""
+        # Not needed here, because e2b.run_code isn't stateful.
+        pass
+
+# (Tip: Do this before adding/removing languages, otherwise OI might retain the state of previous languages:)
+interpreter.computer.terminate()
+
+# Give Open Interpreter its languages. This will only let it run PythonE2B:
+interpreter.computer.languages = [PythonE2B]
+
+# Try it out!
+interpreter.chat("What's 349808*38490739?")
+```

open-interpreter/docs/code-execution/settings.mdx

@@ -0,0 +1,7 @@
+---
+title: Settings
+---
+
+The `interpreter.computer` is responsible for executing code.
+
+[Click here to view `interpreter.computer` settings.](https://docs.openinterpreter.com/settings/all-settings#computer)

open-interpreter/docs/code-execution/usage.mdx

@@ -0,0 +1,36 @@
+---
+title: Usage
+---
+
+# Running Code
+
+The `computer` itself is separate from Open Interpreter's core, so you can run it independently:
+
+```python
+from interpreter import interpreter
+
+interpreter.computer.run("python", "print('Hello World!')")
+```
+
+This runs in the same Python instance that interpreter uses, so you can define functions, variables, or log in to services before the AI starts running code:
+
+```python
+interpreter.computer.run("python", "import replicate\nreplicate.api_key='...'")
+
+interpreter.custom_instructions = "Replicate has already been imported."
+
+interpreter.chat("Please generate an image on replicate...") # Interpreter will be logged into Replicate
+```
+
+# Custom Languages
+
+You also have control over the `computer`'s languages (like Python, Javascript, and Shell), and can easily append custom languages:
+
+<Card
+  title="Custom Languages"
+  icon="code"
+  iconType="solid"
+  href="/code-execution/custom-languages/"
+>
+  Add or customize the programming languages that Open Interpreter can use.
+</Card>

open-interpreter/docs/computer/introduction.mdx

@@ -0,0 +1,13 @@
+The Computer module is responsible for executing code.
+
+You can manually execute code in the same instance that Open Interpreter uses:
+
+```
+
+```
+
+User Usage
+
+It also comes with a suite of modules that we think are particularly useful to code interpreting LLMs.
+
+LLM Usage

open-interpreter/docs/computer/language-model-usage.mdx

@@ -0,0 +1,3 @@
+Open Interpreter can use the Computer module itself.
+
+Here's what it can do:

open-interpreter/docs/computer/user-usage.mdx

@@ -0,0 +1,5 @@
+The Computer module is responsible for running code.
+
+You can add custom languages to it.
+
+The user can add custom languages to the Computer, and .run code on it.

open-interpreter/docs/getting-started/introduction.mdx

@@ -0,0 +1,44 @@
+---
+title: Introduction
+description: A new way to use computers
+---
+
+# <div class="hidden">Introduction</div>
+
+<img src="https://openinterpreter.com/assets/banner.jpg" alt="thumbnail" style={{transform: "translateY(-1.25rem)"}} />
+
+**Open Interpreter** lets language models run code.
+
+You can chat with Open Interpreter through a ChatGPT-like interface in your terminal by running `interpreter` after installing.
+
+This provides a natural-language interface to your computer's general-purpose capabilities:
+
+-   Create and edit photos, videos, PDFs, etc.
+-   Control a Chrome browser to perform research
+-   Plot, clean, and analyze large datasets
+-   ...etc.
+
+<br/>
+
+<Info>You can also build Open Interpreter into your applications with [our new Python package.](/usage/python/arguments)</Info>
+
+---
+
+<h1><span class="font-semibold">Quick start</span></h1>
+
+If you already use Python, you can install Open Interpreter via `pip`:
+
+<Steps>
+  <Step title="Install" icon={"arrow-down"} iconType={"solid"}>
+```bash
+pip install open-interpreter
+```
+  </Step>
+  <Step title="Use" icon={"circle"} iconType={"solid"}>
+```bash
+interpreter
+```
+  </Step>
+</Steps>
+
+We've also developed [one-line installers](setup) that install Python and set up Open Interpreter.

open-interpreter/docs/getting-started/setup.mdx

@@ -0,0 +1,70 @@
+---
+title: Setup
+---
+
+## Experimental one-line installers
+
+To try our experimental installers, open your Terminal with admin privileges [(click here to learn how)](https://chat.openai.com/share/66672c0f-0935-4c16-ac96-75c1afe14fe3), then paste the following commands:
+
+<CodeGroup>
+
+```bash Mac
+curl -sL https://raw.githubusercontent.com/KillianLucas/open-interpreter/main/installers/oi-mac-installer.sh | bash
+```
+
+```powershell Windows
+iex "& {$(irm https://raw.githubusercontent.com/KillianLucas/open-interpreter/main/installers/oi-windows-installer.ps1)}"
+```
+
+```bash Linux
+curl -sL https://raw.githubusercontent.com/KillianLucas/open-interpreter/main/installers/oi-linux-installer.sh | bash
+```
+
+</CodeGroup>
+
+These installers will attempt to download Python, set up an environment, and install Open Interpreter for you.
+
+## Terminal usage
+
+After installation, you can start an interactive chat in your terminal by running:
+
+```bash
+interpreter
+```
+
+## Installation from `pip`
+
+If you already use Python, we recommend installing Open Interpreter via `pip`:
+
+```bash
+pip install open-interpreter
+```
+
+<Info>
+  **Note:** You'll need Python
+  [3.10](https://www.python.org/downloads/release/python-3100/) or
+  [3.11](https://www.python.org/downloads/release/python-3110/). Run `python
+  --version` to check yours.
+</Info>
+
+## Python usage
+
+To start an interactive chat in Python, run the following:
+
+```python
+from interpreter import interpreter
+
+interpreter.chat()
+```
+
+You can also pass messages to `interpreter` programmatically:
+
+```python
+interpreter.chat("Get the last 5 BBC news headlines.")
+```
+
+[Click here](/usage/python/streaming-response) to learn how to stream its response into your application.
+
+## No Installation
+
+If configuring your computer environment is challenging, you can press the `,` key on this repository's GitHub page to create a codespace. After a moment, you'll receive a cloud virtual machine environment pre-installed with open-interpreter. You can then start interacting with it directly and freely confirm its execution of system commands without worrying about damaging the system.

open-interpreter/docs/guides/advanced-terminal-usage.mdx

@@ -0,0 +1,16 @@
+---
+title: Advanced Terminal Usage
+---
+
+Magic commands can be used to control the interpreter's behavior in interactive mode:
+
+- `%% [shell commands, like ls or cd]`: Run commands in Open Interpreter's shell instance
+- `%verbose [true/false]`: Toggle verbose mode. Without arguments or with 'true', it enters verbose mode. With 'false', it exits verbose mode.
+- `%reset`: Reset the current session.
+- `%undo`: Remove previous messages and its response from the message history.
+- `%save_message [path]`: Saves messages to a specified JSON path. If no path is provided, it defaults to 'messages.json'.
+- `%load_message [path]`: Loads messages from a specified JSON path. If no path is provided, it defaults to 'messages.json'.
+- `%tokens [prompt]`: EXPERIMENTAL: Calculate the tokens used by the next request based on the current conversation's messages and estimate the cost of that request; optionally provide a prompt to also calculate the tokens used by that prompt and the total amount of tokens that will be sent with the next request.
+- `%info`: Show system and interpreter information.
+- `%help`: Show this help message.
+- `%jupyter`: Export the current session to a Jupyter notebook file (.ipynb) to the Downloads folder.

open-interpreter/docs/guides/basic-usage.mdx

@@ -0,0 +1,153 @@
+---
+title: Basic Usage
+---
+
+<CardGroup>
+
+<Card
+  title="Interactive demo"
+  icon="gamepad-modern"
+  iconType="solid"
+  href="https://colab.research.google.com/drive/1WKmRXZgsErej2xUriKzxrEAXdxMSgWbb?usp=sharing"
+>
+  Try Open Interpreter without installing anything on your computer
+</Card>
+
+<Card
+  title="Example voice interface"
+  icon="circle"
+  iconType="solid"
+  href="https://colab.research.google.com/drive/1NojYGHDgxH6Y1G1oxThEBBb2AtyODBIK"
+>
+  An example implementation of Open Interpreter's streaming capabilities
+</Card>
+
+</CardGroup>
+
+---
+
+### Interactive Chat
+
+To start an interactive chat in your terminal, either run `interpreter` from the command line:
+
+```shell
+interpreter
+```
+
+Or `interpreter.chat()` from a .py file:
+
+```python
+interpreter.chat()
+```
+
+---
+
+### Programmatic Chat
+
+For more precise control, you can pass messages directly to `.chat(message)` in Python:
+
+```python
+interpreter.chat("Add subtitles to all videos in /videos.")
+
+# ... Displays output in your terminal, completes task ...
+
+interpreter.chat("These look great but can you make the subtitles bigger?")
+
+# ...
+```
+
+---
+
+### Start a New Chat
+
+In your terminal, Open Interpreter behaves like ChatGPT and will not remember previous conversations. Simply run `interpreter` to start a new chat:
+
+```shell
+interpreter
+```
+
+In Python, Open Interpreter remembers conversation history. If you want to start fresh, you can reset it:
+
+```python
+interpreter.messages = []
+```
+
+---
+
+### Save and Restore Chats
+
+In your terminal, Open Interpreter will save previous conversations to `<your application directory>/Open Interpreter/conversations/`.
+
+You can resume any of them by running `--conversations`. Use your arrow keys to select one , then press `ENTER` to resume it.
+
+```shell
+interpreter --conversations
+```
+
+In Python, `interpreter.chat()` returns a List of messages, which can be used to resume a conversation with `interpreter.messages = messages`:
+
+```python
+# Save messages to 'messages'
+messages = interpreter.chat("My name is Killian.")
+
+# Reset interpreter ("Killian" will be forgotten)
+interpreter.messages = []
+
+# Resume chat from 'messages' ("Killian" will be remembered)
+interpreter.messages = messages
+```
+
+---
+
+### Configure Default Settings
+
+We save default settings to the `default.yaml` profile which can be opened and edited by running the following command:
+
+```shell
+interpreter --profiles
+```
+
+You can use this to set your default language model, system message (custom instructions), max budget, etc.
+
+<Info>
+  **Note:** The Python library will also inherit settings from the default
+  profile file. You can change it by running `interpreter --profiles` and
+  editing `default.yaml`.
+</Info>
+
+---
+
+### Customize System Message
+
+In your terminal, modify the system message by [editing your configuration file as described here](#configure-default-settings).
+
+In Python, you can inspect and configure Open Interpreter's system message to extend its functionality, modify permissions, or give it more context.
+
+```python
+interpreter.system_message += """
+Run shell commands with -y so the user doesn't have to confirm them.
+"""
+print(interpreter.system_message)
+```
+
+---
+
+### Change your Language Model
+
+Open Interpreter uses [LiteLLM](https://docs.litellm.ai/docs/providers/) to connect to language models.
+
+You can change the model by setting the model parameter:
+
+```shell
+interpreter --model gpt-3.5-turbo
+interpreter --model claude-2
+interpreter --model command-nightly
+```
+
+In Python, set the model on the object:
+
+```python
+interpreter.llm.model = "gpt-3.5-turbo"
+```
+
+[Find the appropriate "model" string for your language model here.](https://docs.litellm.ai/docs/providers/)

open-interpreter/docs/guides/demos.mdx

@@ -0,0 +1,59 @@
+---
+title: Demos
+---
+
+### Vision Mode
+
+#### Recreating a Tailwind Component
+
+Creating a dropdown menu in Tailwind from a single screenshot:
+
+<iframe src="data:text/html;charset=utf-8,%0A%3Cblockquote%20class%3D%22twitter-tweet%22%20data-media-max-width%3D%22560%22%3E%0A%20%20%20%20%3Cp%20lang%3D%22en%22%20dir%3D%22ltr%22%3Ewe%26%2339%3Bve%20literally%20been%20flying%20blind%20until%20now%3Cbr%3E%3Cbr%3E%0A%20%20%20%20%24%20interpreter%20--vision%3Cbr%3E%0A%20%20%20%20%26gt%3B%20Recreate%20this%20component%20in%20Tailwind%20CSS%3Cbr%3E%3Cbr%3E%0A%20%20%20%20%28this%20is%20realtime%29%20%3Ca%20href%3D%22https%3A//t.co/PyVm11mclF%22%3Epic.twitter.com/PyVm11mclF%3C/a%3E%0A%20%20%20%20%3C/p%3E%26mdash%3B%20killian%20%28%40hellokillian%29%20%0A%20%20%20%20%3Ca%20href%3D%22https%3A//twitter.com/hellokillian/status/1723106008061587651%3Fref_src%3Dtwsrc%255Etfw%22%3ENovember%2010%2C%202023%3C/a%3E%0A%3C/blockquote%3E%20%0A%3Cscript%20async%20src%3D%22https%3A//platform.twitter.com/widgets.js%22%20charset%3D%22utf-8%22%3E%3C/script%3E%0A" width="100%" height="500"></iframe>
+
+#### Recreating the ChatGPT interface using GPT-4V:
+
+<iframe src="data:text/html;charset=utf-8,%0A%3Cblockquote%20class%3D%22twitter-tweet%22%20data-media-max-width%3D%22560%22%3E%0A%20%20%20%20%3Cp%20lang%3D%22en%22%20dir%3D%22ltr%22%3EOpen%20Interpreter%20%2B%20Vision%20-%20with%20the%20self-improving%20feedback%20loop%20is%20%F0%9F%91%8C%20%3Cbr%3E%3Cbr%3E%0A%20%20%20%20Here%20is%20how%20it%20iterates%20to%20recreate%20the%20ChatGPT%20UI%20%F0%9F%A4%AF%3Cbr%3E%3Cbr%3E%0A%20%20%20%20%284x%20speedup%29%20%3Ca%20href%3D%22https%3A//t.co/HphKMOWBiB%22%3Epic.twitter.com/HphKMOWBiB%3C/a%3E%0A%20%20%20%20%3C/p%3E%26mdash%3B%20chilang%20%28%40chilang%29%20%0A%20%20%20%20%3Ca%20href%3D%22https%3A//twitter.com/chilang/status/1724577200135897255%3Fref_src%3Dtwsrc%255Etfw%22%3ENovember%2014%2C%202023%3C/a%3E%0A%3C/blockquote%3E%20%0A%3Cscript%20async%20src%3D%22https%3A//platform.twitter.com/widgets.js%22%20charset%3D%22utf-8%22%3E%3C/script%3E%0A" width="100%" height="500"></iframe>
+
+### OS Mode
+
+#### Playing Music
+
+Open Interpreter playing some Lofi using OS mode:
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/-n8qYi5HhO8?si=huEpYFBEwotBIMMs" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
+
+#### Open Interpreter Chatting with Open Interpreter
+
+OS mode creating and chatting with a local instance of Open Interpreter:
+
+<iframe src="data:text/html;charset=utf-8,%0A%3Cblockquote%20class%3D%22twitter-tweet%22%20data-media-max-width%3D%22560%22%3E%0A%20%20%20%20%3Cp%20lang%3D%22en%22%20dir%3D%22ltr%22%3EComputer-operating%20AI%20can%20replicate%20itself%20onto%20other%20systems.%20%F0%9F%A4%AF%3Cbr%3E%3Cbr%3E%0A%20%20%20%20Open%20Interpreter%20uses%20my%20mouse%20and%20keyboard%20to%20start%20a%20local%20instance%20of%20itself%3A%20%0A%20%20%20%20%3Ca%20href%3D%22https%3A//t.co/1BZWRA4FMn%22%3Epic.twitter.com/1BZWRA4FMn%3C/a%3E%3C/p%3E%26mdash%3B%20Ty%20%28%40FieroTy%29%20%0A%20%20%20%20%3Ca%20href%3D%22https%3A//twitter.com/FieroTy/status/1746639975234560101%3Fref_src%3Dtwsrc%255Etfw%22%3EJanuary%2014%2C%202024%3C/a%3E%0A%3C/blockquote%3E%20%0A%3Cscript%20async%20src%3D%22https%3A//platform.twitter.com/widgets.js%22%20charset%3D%22utf-8%22%3E%3C/script%3E%0A" width="100%" height="500"></iframe>
+
+#### Controlling an Arduino
+
+Reading temperature and humidity from an Arudino:
+
+<iframe src="data:text/html;charset=utf-8,%0A%20%20%20%20%20%20%20%20%20%20%20%20%3Cblockquote%20class%3D%22twitter-tweet%22%20data-media-max-width%3D%22560%22%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Cp%20lang%3D%22en%22%20dir%3D%22ltr%22%3EThis%20time%20I%20showed%20it%20an%20image%20of%20a%20temp%20sensor%2C%20LCD%20%26amp%3B%20Arduino.%3Cbr%3E%3Cbr%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20And%20it%20wrote%20a%20program%20to%20read%20the%20temperature%20%26amp%3B%20humidity%20from%20the%20sensor%20%26amp%3B%20show%20it%20on%20the%20LCD%20%F0%9F%A4%AF%3Cbr%3E%3Cbr%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20Still%20blown%20away%20by%20how%20good%20%40hellokillian%27s%20Open%20Interpreter%20is%21%3Cbr%3E%3Cbr%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20p.s.%20-%20ignore%20the%20cat%20fight%20in%20the%20background%20%3Ca%20href%3D%22https%3A//t.co/tG9sSdkfD5%22%3Ehttps%3A//t.co/tG9sSdkfD5%3C/a%3E%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Ca%20href%3D%22https%3A//t.co/B6sH4absff%22%3Epic.twitter.com/B6sH4absff%3C/a%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3C/p%3E%26mdash%3B%20Vindiw%20Wijesooriya%20%28%40vindiww%29%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Ca%20href%3D%22https%3A//twitter.com/vindiww/status/1744252926321942552%3Fref_src%3Dtwsrc%255Etfw%22%3EJanuary%208%2C%202024%3C/a%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%3C/blockquote%3E%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%3Cscript%20async%20src%3D%22https%3A//platform.twitter.com/widgets.js%22%20charset%3D%22utf-8%22%3E%3C/script%3E%0A%20%20%20%20%20%20%20%20" width="100%" height="500"></iframe>
+
+#### Music Creation
+
+OS mode using Logic Pro X to record a piano song and play it back:
+
+<iframe src="data:text/html;charset=utf-8,%0A%20%20%20%20%20%20%20%20%20%20%20%20%3Cblockquote%20class%3D%22twitter-tweet%22%20data-media-max-width%3D%22560%22%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Cp%20lang%3D%22en%22%20dir%3D%22ltr%22%3Eit%27s%20not%20quite%20Mozart%2C%20but...%3Cbr%3E%3Cbr%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20this%20is%20Open%20Interpreter%20firing%20up%20Logic%20Pro%20to%20write/record%20a%20song%21%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Ca%20href%3D%22https%3A//t.co/vPHpPvjk4b%22%3Epic.twitter.com/vPHpPvjk4b%3C/a%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3C/p%3E%26mdash%3B%20Ty%20%28%40FieroTy%29%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Ca%20href%3D%22https%3A//twitter.com/FieroTy/status/1744203268451111035%3Fref_src%3Dtwsrc%255Etfw%22%3EJanuary%208%2C%202024%3C/a%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%3C/blockquote%3E%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%3Cscript%20async%20src%3D%22https%3A//platform.twitter.com/widgets.js%22%20charset%3D%22utf-8%22%3E%3C/script%3E%0A%20%20%20%20%20%20%20%20" width="100%" height="500"></iframe>
+
+#### Generating images in Everart.ai
+
+Open Interpreter describing pictures it wants to make, then creating them using OS mode:
+
+<iframe src="data:text/html;charset=utf-8,%0A%20%20%20%20%20%20%20%20%20%20%20%20%3Cblockquote%20class%3D%22twitter-tweet%22%20data-media-max-width%3D%22560%22%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Cp%20lang%3D%22en%22%20dir%3D%22ltr%22%3EThis%20is%20wild.%20I%20gave%20OS%20control%20to%20GPT-4%20via%20the%20latest%20update%20of%20Open%20Interpreter%20and%20now%20it%27s%20generating%20pictures%20it%20wants%20to%20see%20in%20%40everartai%20%F0%9F%A4%AF%3Cbr%3E%3Cbr%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20GPT%20is%20controlling%20the%20mouse%20and%20adding%20text%20in%20the%20fields%2C%20I%20am%20not%20doing%20anything.%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Ca%20href%3D%22https%3A//t.co/hGgML9epEc%22%3Epic.twitter.com/hGgML9epEc%3C/a%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3C/p%3E%26mdash%3B%20Pietro%20Schirano%20%28%40skirano%29%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Ca%20href%3D%22https%3A//twitter.com/skirano/status/1747670816437735836%3Fref_src%3Dtwsrc%255Etfw%22%3EJanuary%2017%2C%202024%3C/a%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%3C/blockquote%3E%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%3Cscript%20async%20src%3D%22https%3A//platform.twitter.com/widgets.js%22%20charset%3D%22utf-8%22%3E%3C/script%3E%0A%20%20%20%20%20%20%20%20" width="100%" height="500"></iframe>
+
+#### Open Interpreter Conversing With ChatGPT
+
+OS mode has a conversation with ChatGPT and even asks it "What do you think about human/AI interaction?"
+
+<iframe src="data:text/html;charset=utf-8,%0A%20%20%20%20%20%20%20%20%20%20%20%20%3Cblockquote%20class%3D%22twitter-tweet%22%20data-media-max-width%3D%22560%22%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Cp%20lang%3D%22en%22%20dir%3D%22ltr%22%3EWatch%20GPT%20Vision%20with%20control%20over%20my%20OS%20talking%20to%20ChatGPT.%3Cbr%3E%3Cbr%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20The%20most%20fascinating%20part%20is%20that%20it%27s%20intrigued%20by%20having%20a%20conversation%20with%20another%20%22similar.%22%3Cbr%3E%3Cbr%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22What%20do%20you%20think%20about%20human/AI%20interaction%3F%22%20it%20asked.%3Cbr%3E%3Cbr%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20Also%2C%20the%20superhuman%20speed%20at%20which%20it%20types%2C%20lol%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Ca%20href%3D%22https%3A//t.co/ViffvDK5H9%22%3Epic.twitter.com/ViffvDK5H9%3C/a%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3C/p%3E%26mdash%3B%20Pietro%20Schirano%20%28%40skirano%29%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Ca%20href%3D%22https%3A//twitter.com/skirano/status/1747772471770583190%3Fref_src%3Dtwsrc%255Etfw%22%3EJanuary%2018%2C%202024%3C/a%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%3C/blockquote%3E%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%3Cscript%20async%20src%3D%22https%3A//platform.twitter.com/widgets.js%22%20charset%3D%22utf-8%22%3E%3C/script%3E%0A%20%20%20%20%20%20%20%20" width="100%" height="500"></iframe>
+
+#### Sending an Email with Gmail
+
+OS mode launches Safari, composes an email, and sends it:
+
+<iframe src="data:text/html;charset=utf-8,%0A%20%20%20%20%20%20%20%20%20%20%20%20%3Cblockquote%20class%3D%22twitter-tweet%22%20data-media-max-width%3D%22560%22%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Cp%20lang%3D%22en%22%20dir%3D%22ltr%22%3ELook%20ma%2C%20no%20hands%21%20This%20is%20%40OpenInterpreter%20using%20my%20mouse%20and%20keyboard%20to%20send%20an%20email.%20%3Cbr%3E%3Cbr%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20Imagine%20what%20else%20is%20possible.%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Ca%20href%3D%22https%3A//t.co/GcBqbTwD23%22%3Epic.twitter.com/GcBqbTwD23%3C/a%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3C/p%3E%26mdash%3B%20Ty%20%28%40FieroTy%29%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%3Ca%20href%3D%22https%3A//twitter.com/FieroTy/status/1743437525207928920%3Fref_src%3Dtwsrc%255Etfw%22%3EJanuary%206%2C%202024%3C/a%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%3C/blockquote%3E%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%3Cscript%20async%20src%3D%22https%3A//platform.twitter.com/widgets.js%22%20charset%3D%22utf-8%22%3E%3C/script%3E%0A%20%20%20%20%20%20%20%20" width="100%" height="500"></iframe>

open-interpreter/docs/guides/multiple-instances.mdx

@@ -0,0 +1,37 @@
+---
+title: Multiple Instances
+---
+
+To create multiple instances, use the base class, `OpenInterpreter`:
+
+```python
+from interpreter import OpenInterpreter
+
+agent_1 = OpenInterpreter()
+agent_1.system_message = "This is a separate instance."
+
+agent_2 = OpenInterpreter()
+agent_2.system_message = "This is yet another instance."
+```
+
+For fun, you could make these instances talk to eachother:
+
+```python
+def swap_roles(messages):
+    for message in messages:
+        if message['role'] == 'user':
+            message['role'] = 'assistant'
+        elif message['role'] == 'assistant':
+            message['role'] = 'user'
+    return messages
+
+agents = [agent_1, agent_2]
+
+# Kick off the conversation
+messages = [{"role": "user", "message": "Hello!"}]
+
+while True:
+    for agent in agents:
+        messages = agent.chat(messages)
+        messages = swap_roles(messages)
+```

open-interpreter/docs/guides/os-mode.mdx

@@ -0,0 +1,17 @@
+---
+title: OS Mode
+---
+
+OS mode is a highly experimental mode that allows Open Interpreter to control the operating system visually through the mouse and keyboard. It provides a multimodal LLM like GPT-4V with the necessary tools to capture screenshots of the display and interact with on-screen elements such as text and icons. It will try to use the most direct method to achieve the goal, like using spotlight on Mac to open applications, and using query parameters in the URL to open websites with additional information.
+
+OS mode is a work in progress, if you have any suggestions or experience issues, please reach out on our [Discord](https://discord.com/invite/6p3fD6rBVm).
+
+To enable OS Mode, run the interpreter with the `--os` flag:
+
+```bash
+interpreter --os
+```
+
+Please note that screen recording permissions must be enabled for your terminal application for OS mode to work properly to work.
+
+OS mode does not currently support multiple displays.

open-interpreter/docs/guides/running-locally.mdx

@@ -0,0 +1,41 @@
+---
+title: Running Locally
+---
+
+In this video, Mike Bird goes over three different methods for running Open Interpreter with a local language model:
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/CEs51hGWuGU?si=cN7f6QhfT4edfG5H" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
+
+## How to Use Open Interpreter Locally
+
+### Ollama
+
+1. Download Ollama from https://ollama.ai/download
+2. Run the command:  
+`ollama run dolphin-mixtral:8x7b-v2.6`
+3. Execute the Open Interpreter:  
+`interpreter --model ollama/dolphin-mixtral:8x7b-v2.6`
+
+### Jan.ai
+
+1. Download Jan from http://jan.ai
+2. Download the model from the Hub
+3. Enable API server:
+   1. Go to Settings
+   2. Navigate to Advanced
+   3. Enable API server
+4. Select the model to use
+5. Run the Open Interpreter with the specified API base:  
+`interpreter --api_base http://localhost:1337/v1 --model mixtral-8x7b-instruct`
+
+### Llamafile
+
+⚠ Ensure that Xcode is installed for Apple Silicon
+
+1. Download or create a llamafile from https://github.com/Mozilla-Ocho/llamafile
+2. Make the llamafile executable:  
+`chmod +x mixtral-8x7b-instruct-v0.1.Q5_K_M.llamafile`
+3. Execute the llamafile:  
+`./mixtral-8x7b-instruct-v0.1.Q5_K_M.llamafile`
+4. Run the interpreter with the specified API base:  
+`interpreter --api_base https://localhost:8080/v1`

open-interpreter/docs/guides/streaming-response.mdx

@@ -0,0 +1,159 @@
+---
+title: Streaming Response
+---
+
+You can stream messages, code, and code outputs out of Open Interpreter by setting `stream=True` in an `interpreter.chat(message)` call.
+
+```python
+for chunk in interpreter.chat("What's 34/24?", stream=True, display=False):
+  print(chunk)
+```
+
+```
+{"role": "assistant", "type": "code", "format": "python", "start": True}
+{"role": "assistant", "type": "code", "format": "python", "content": "34"}
+{"role": "assistant", "type": "code", "format": "python", "content": " /"}
+{"role": "assistant", "type": "code", "format": "python", "content": " "}
+{"role": "assistant", "type": "code", "format": "python", "content": "24"}
+{"role": "assistant", "type": "code", "format": "python", "end": True}
+
+{"role": "computer", "type": "confirmation", "format": "execution", "content": {"type": "code", "format": "python", "content": "34 / 24"}},
+
+{"role": "computer", "type": "console", "start": True}
+{"role": "computer", "type": "console", "format": "active_line", "content": "1"}
+{"role": "computer", "type": "console", "format": "output", "content": "1.4166666666666667\n"}
+{"role": "computer", "type": "console", "format": "active_line", "content": None},
+{"role": "computer", "type": "console", "end": True}
+
+{"role": "assistant", "type": "message", "start": True}
+{"role": "assistant", "type": "message", "content": "The"}
+{"role": "assistant", "type": "message", "content": " result"}
+{"role": "assistant", "type": "message", "content": " of"}
+{"role": "assistant", "type": "message", "content": " the"}
+{"role": "assistant", "type": "message", "content": " division"}
+{"role": "assistant", "type": "message", "content": " "}
+{"role": "assistant", "type": "message", "content": "34"}
+{"role": "assistant", "type": "message", "content": "/"}
+{"role": "assistant", "type": "message", "content": "24"}
+{"role": "assistant", "type": "message", "content": " is"}
+{"role": "assistant", "type": "message", "content": " approximately"}
+{"role": "assistant", "type": "message", "content": " "}
+{"role": "assistant", "type": "message", "content": "1"}
+{"role": "assistant", "type": "message", "content": "."}
+{"role": "assistant", "type": "message", "content": "42"}
+{"role": "assistant", "type": "message", "content": "."}
+{"role": "assistant", "type": "message", "end": True}
+```
+
+**Note:** Setting `display=True` won't change the behavior of the streaming response, it will just render a display in your terminal.
+
+# Anatomy
+
+Each chunk of the streamed response is a dictionary, that has a "role" key that can be either "assistant" or "computer". The "type" key describes what the chunk is. The "content" key contains the actual content of the chunk.
+
+Every 'message' is made up of chunks, and begins with a "start" chunk, and ends with an "end" chunk. This helps you parse the streamed response into messages.
+
+Let's break down each part of the streamed response.
+
+## Code
+
+In this example, the LLM decided to start writing code first. It could have decided to write a message first, or to only write code, or to only write a message.
+
+Every streamed chunk of type "code" has a format key that specifies the language. In this case it decided to write `python`.
+
+This can be any language defined in [our languages directory.](https://github.com/KillianLucas/open-interpreter/tree/main/interpreter/core/computer/terminal/languages)
+
+```
+
+{"role": "assistant", "type": "code", "format": "python", "start": True}
+
+```
+
+Then, the LLM decided to write some code. The code is sent token-by-token:
+
+```
+
+{"role": "assistant", "type": "code", "format": "python", "content": "34"}
+{"role": "assistant", "type": "code", "format": "python", "content": " /"}
+{"role": "assistant", "type": "code", "format": "python", "content": " "}
+{"role": "assistant", "type": "code", "format": "python", "content": "24"}
+
+```
+
+When the LLM finishes writing code, it will send an "end" chunk:
+
+```
+
+{"role": "assistant", "type": "code", "format": "python", "end": True}
+
+```
+
+## Code Output
+
+After the LLM finishes writing a code block, Open Interpreter will attempt to run it.
+
+**Before** it runs it, the following chunk is sent:
+
+```
+
+{"role": "computer", "type": "confirmation", "format": "execution", "content": {"type": "code", "language": "python", "code": "34 / 24"}}
+
+```
+
+If you check for this object, you can break (or get confirmation) **before** executing the code.
+
+```python
+# This example asks the user before running code
+
+for chunk in interpreter.chat("What's 34/24?", stream=True):
+    if "executing" in chunk:
+        if input("Press ENTER to run this code.") != "":
+            break
+```
+
+**While** the code is being executed, you'll receive the line of code that's being run:
+
+```
+{"role": "computer", "type": "console", "format": "active_line", "content": "1"}
+```
+
+We use this to highlight the active line of code on our UI, which keeps the user aware of what Open Interpreter is doing.
+
+You'll then receive its output, if it produces any:
+
+```
+{"role": "computer", "type": "console", "format": "output", "content": "1.4166666666666667\n"}
+```
+
+When the code is **finished** executing, this flag will be sent:
+
+```
+{"role": "computer", "type": "console", "end": True}
+```
+
+## Message
+
+Finally, the LLM decided to write a message. This is streamed token-by-token as well:
+
+```
+{"role": "assistant", "type": "message", "start": True}
+{"role": "assistant", "type": "message", "content": "The"}
+{"role": "assistant", "type": "message", "content": " result"}
+{"role": "assistant", "type": "message", "content": " of"}
+{"role": "assistant", "type": "message", "content": " the"}
+{"role": "assistant", "type": "message", "content": " division"}
+{"role": "assistant", "type": "message", "content": " "}
+{"role": "assistant", "type": "message", "content": "34"}
+{"role": "assistant", "type": "message", "content": "/"}
+{"role": "assistant", "type": "message", "content": "24"}
+{"role": "assistant", "type": "message", "content": " is"}
+{"role": "assistant", "type": "message", "content": " approximately"}
+{"role": "assistant", "type": "message", "content": " "}
+{"role": "assistant", "type": "message", "content": "1"}
+{"role": "assistant", "type": "message", "content": "."}
+{"role": "assistant", "type": "message", "content": "42"}
+{"role": "assistant", "type": "message", "content": "."}
+{"role": "assistant", "type": "message", "end": True}
+```
+
+For an example in JavaScript on how you might process these streamed chunks, see the [migration guide](https://github.com/KillianLucas/open-interpreter/blob/main/docs/NCU_MIGRATION_GUIDE.md)

open-interpreter/docs/integrations/docker.mdx

@@ -0,0 +1,64 @@
+---
+title: Docker
+---
+
+Docker support is currently experimental. Running Open Interpreter inside of a Docker container may not function as you expect. Let us know on [Discord](https://discord.com/invite/6p3fD6rBVm) if you encounter errors or have suggestions to improve Docker support.
+
+We are working on an official integration for Docker in the coming weeks. For now, you can use Open Interpreter in a sandboxed Docker container environment using the following steps:
+
+1. If you do not have Docker Desktop installed, [install it](https://www.docker.com/products/docker-desktop) before proceeding.
+
+2. Create a new directory and add a file named `Dockerfile` in it with the following contents:
+
+```dockerfile
+# Start with Python 3.11
+FROM python:3.11
+
+# Replace <your_openai_api_key> with your own key
+ENV OPENAI_API_KEY <your_openai_api_key>
+
+# Install Open Interpreter
+RUN pip install open-interpreter
+```
+
+3. Run the following commands in the same directory to start Open Interpreter.
+
+```bash
+docker build -t openinterpreter .
+docker run -d -it --name interpreter-instance openinterpreter interpreter
+docker attach interpreter-instance
+```
+
+## Mounting Volumes
+
+This is how you let it access _some_ files, by telling it a folder (a volume) it will be able to see / manipulate.
+
+To mount a volume, you can use the `-v` flag followed by the path to the directory on your host machine, a colon, and then the path where you want to mount the directory in the container.
+
+```bash
+docker run -d -it -v /path/on/your/host:/path/in/the/container --name interpreter-instance openinterpreter interpreter
+```
+
+Replace `/path/on/your/host` with the path to the directory on your host machine that you want to mount, and replace `/path/in/the/container` with the path in the Docker container where you want to mount the directory.
+
+Here's a simple example:
+
+```bash
+docker run -d -it -v $(pwd):/files --name interpreter-instance openinterpreter interpreter
+```
+
+In this example, `$(pwd)` is your current directory, and it is mounted to a `/files` directory in the Docker container (this creates that folder too).
+
+## Flags
+
+To add flags to the command, just append them after `interpreter`. For example, to run the interpreter with custom instructions, run the following command:
+
+```bash
+docker-compose run --rm oi interpreter --custom_instructions "Be as concise as possible"
+```
+
+Please note that some flags will not work. For example, `--config` will not work, because it cannot open the config file in the container. If you want to use a config file other than the default, you can create a `config.yml` file inside of the same directory, add your custom config, and then run the following command:
+
+```bash
+docker-compose run --rm oi interpreter --config_file config.yml
+```

open-interpreter/docs/integrations/e2b.mdx

@@ -0,0 +1,72 @@
+---
+title: E2B
+---
+
+[E2B](https://e2b.dev/) is a secure, sandboxed environment where you can run arbitrary code.
+
+To build this integration, you just need to replace Open Interpreter's `python` (which runs locally) with a `python` that runs on E2B.
+
+First, [get an API key here](https://e2b.dev/), and set it:
+
+```python
+import os
+os.environ["E2B_API_KEY"] = "<your_api_key_here>"
+```
+
+Then, define a custom language for Open Interpreter. The class name doesn't matter, but we'll call it `PythonE2B`:
+
+```python
+import e2b
+
+class PythonE2B:
+    """
+    This class contains all requirements for being a custom language in Open Interpreter:
+
+    - name (an attribute)
+    - run (a method)
+    - stop (a method)
+    - terminate (a method)
+
+    Here, we'll use E2B to power the `run` method.
+    """
+
+    # This is the name that will appear to the LLM.
+    name = "python"
+
+    # Optionally, you can append some information about this language to the system message:
+    system_message = "# Follow this rule: Every Python code block MUST contain at least one print statement."
+
+    # (E2B isn't a Jupyter Notebook, so we added ^ this so it would print things,
+    # instead of putting variables at the end of code blocks, which is a Jupyter thing.)
+
+    def run(self, code):
+        """Generator that yields a dictionary in LMC Format."""
+
+        # Run the code on E2B
+        stdout, stderr = e2b.run_code('Python3', code)
+
+        # Yield the output
+        yield {
+            "type": "console", "format": "output",
+            "content": stdout + stderr # We combined these arbitrarily. Yield anything you'd like!
+        }
+
+    def stop(self):
+        """Stops the code."""
+        # Not needed here, because e2b.run_code isn't stateful.
+        pass
+
+    def terminate(self):
+        """Terminates the entire process."""
+        # Not needed here, because e2b.run_code isn't stateful.
+        pass
+
+# (Tip: Do this before adding/removing languages, otherwise OI might retain the state of previous languages:)
+interpreter.computer.terminate()
+
+# Give Open Interpreter its languages. This will only let it run PythonE2B:
+interpreter.computer.languages = [PythonE2B]
+
+# Try it out!
+interpreter.chat("What's 349808*38490739?")
+```

open-interpreter/docs/language-models/custom-models.mdx

@@ -0,0 +1,42 @@
+---
+title: Custom Models
+---
+
+In addition to hosted and local language models, Open Interpreter also supports custom models.
+
+As long as your system can accept an input and stream an output (and can be interacted with via a Python generator) it can be used as a language model in Open Interpreter.
+
+Simply replace the OpenAI-compatible `completions` function in your language model with one of your own:
+
+```python
+def custom_language_model(openai_message):
+    """
+    OpenAI-compatible completions function (this one just echoes what the user said back).
+    """
+    users_content = openai_message[-1].get("content") # Get last message's content
+
+    # To make it OpenAI-compatible, we yield this first:
+    yield {"delta": {"role": "assistant"}}
+
+    for character in users_content:
+        yield {"delta": {"content": character}}
+
+# Tell Open Interpreter to power the language model with this function
+
+interpreter.llm.completion = custom_language_model
+```
+
+Then, set the following settings:
+
+```
+interpreter.llm.context_window = 2000 # In tokens
+interpreter.llm.max_tokens = 1000 # In tokens
+interpreter.llm.supports_vision = False # Does this completions endpoint accept images?
+interpreter.llm.supports_functions = False # Does this completions endpoint accept/return function calls?
+```
+
+And start using it:
+
+```
+interpreter.chat("Hi!") # Returns/displays "Hi!" character by character
+```

open-interpreter/docs/language-models/hosted-models/ai21.mdx

@@ -0,0 +1,48 @@
+---
+title: AI21
+---
+
+To use Open Interpreter with a model from AI21, set the `model` flag:
+
+<CodeGroup>
+
+```bash Terminal
+interpreter --model j2-light
+```
+
+```python Python
+from interpreter import interpreter
+
+interpreter.llm.model = "j2-light"
+interpreter.chat()
+```
+
+</CodeGroup>
+
+# Supported Models
+
+We support any model from [AI21:](https://www.ai21.com/)
+
+<CodeGroup>
+
+```bash Terminal
+interpreter --model j2-light
+interpreter --model j2-mid
+interpreter --model j2-ultra
+```
+
+```python Python
+interpreter.llm.model = "j2-light"
+interpreter.llm.model = "j2-mid"
+interpreter.llm.model = "j2-ultra"
+```
+
+</CodeGroup>
+
+# Required Environment Variables
+
+Set the following environment variables [(click here to learn how)](https://chat.openai.com/share/1062cdd8-62a1-4aa8-8ec9-eca45645971a) to use these models.
+
+| Environment Variable  | Description  | Where to Find  |
+| --------------------- | ------------ | -------------- |
+| `AI21_API_KEY`       | The API key for authenticating to AI21's services. | [AI21 Account Page](https://www.ai21.com/account/api-keys) |

open-interpreter/docs/language-models/hosted-models/anthropic.mdx

@@ -0,0 +1,48 @@
+---
+title: Anthropic
+---
+
+To use Open Interpreter with a model from Anthropic, set the `model` flag:
+
+<CodeGroup>
+
+```bash Terminal
+interpreter --model claude-instant-1
+```
+
+```python Python
+from interpreter import interpreter
+
+interpreter.llm.model = "claude-instant-1"
+interpreter.chat()
+```
+
+</CodeGroup>
+
+# Supported Models
+
+We support any model from [Anthropic:](https://www.anthropic.com/)
+
+<CodeGroup>
+
+```bash Terminal
+interpreter --model claude-instant-1
+interpreter --model claude-instant-1.2
+interpreter --model claude-2
+```
+
+```python Python
+interpreter.llm.model = "claude-instant-1"
+interpreter.llm.model = "claude-instant-1.2"
+interpreter.llm.model = "claude-2"
+```
+
+</CodeGroup>
+
+# Required Environment Variables
+
+Set the following environment variables [(click here to learn how)](https://chat.openai.com/share/1062cdd8-62a1-4aa8-8ec9-eca45645971a) to use these models.
+
+| Environment Variable  | Description  | Where to Find  |
+| --------------------- | ------------ | -------------- |
+| `ANTHROPIC_API_KEY`       | The API key for authenticating to Anthropic's services. | [Anthropic](https://www.anthropic.com/) |

open-interpreter/docs/language-models/hosted-models/anyscale.mdx

@@ -0,0 +1,60 @@
+---
+title: Anyscale
+---
+
+To use Open Interpreter with a model from Anyscale, set the `model` flag:
+
+<CodeGroup>
+
+```bash Terminal
+interpreter --model anyscale/<model-name>
+```
+
+```python Python
+from interpreter import interpreter
+
+# Set the model to use from AWS Bedrock:
+interpreter.llm.model = "anyscale/<model-name>"
+interpreter.chat()
+```
+
+</CodeGroup>
+
+# Supported Models
+
+We support the following completion models from Anyscale:
+
+- Llama 2 7B Chat
+- Llama 2 13B Chat
+- Llama 2 70B Chat
+- Mistral 7B Instruct
+- CodeLlama 34b Instruct
+
+<CodeGroup>
+
+```bash Terminal
+interpreter --model anyscale/meta-llama/Llama-2-7b-chat-hf
+interpreter --model anyscale/meta-llama/Llama-2-13b-chat-hf
+interpreter --model anyscale/meta-llama/Llama-2-70b-chat-hf
+interpreter --model anyscale/mistralai/Mistral-7B-Instruct-v0.1
+interpreter --model anyscale/codellama/CodeLlama-34b-Instruct-hf
+```
+
+```python Python
+interpreter.llm.model = "anyscale/meta-llama/Llama-2-7b-chat-hf"
+interpreter.llm.model = "anyscale/meta-llama/Llama-2-13b-chat-hf"
+interpreter.llm.model = "anyscale/meta-llama/Llama-2-70b-chat-hf"
+interpreter.llm.model = "anyscale/mistralai/Mistral-7B-Instruct-v0.1"
+interpreter.llm.model = "anyscale/codellama/CodeLlama-34b-Instruct-hf"
+
+```
+
+</CodeGroup>
+
+# Required Environment Variables
+
+Set the following environment variables [(click here to learn how)](https://chat.openai.com/share/1062cdd8-62a1-4aa8-8ec9-eca45645971a) to use these models.
+
+| Environment Variable | Description                            | Where to Find                                                               |
+| -------------------- | -------------------------------------- | --------------------------------------------------------------------------- |
+| `ANYSCALE_API_KEY`   | The API key for your Anyscale account. | [Anyscale Account Settings](https://app.endpoints.anyscale.com/credentials) |