Skip to content
This repository has been archived by the owner on Mar 16, 2024. It is now read-only.

Releases: emrgnt-cmplxty/automata

v0.0.5

22 Jul 13:02
24a0330
Compare
Choose a tag to compare
v0.0.5 Pre-release
Pre-release

Here's the summary of the release notes written with appropriate Markdown:

Release Notes Summary for 'automata' v0.0.5

  1. Code Cleanups: Attempts were made to clean up the config by @emrgnt-cmplxty.

  2. Test Updates: Additional tests for the CLI were introduced by @NolanTrem, and more tests were added by @emrgnt-cmplxty.

  3. Configuration Updates: Pydantic was rolled back, configuration was refactored, and a CLI configure command was added.

  4. Feature Additions: New features include token meters, a py_reader, read/write tools, an onboard evaluation system, and extensions to evaluations by @emrgnt-cmplxty.

  5. Code Fixes: Fixes include a small change for OPENAI_API_KEY in setup, a logging reconfigure, and an adjustment for the nightly eval to use poetry.

  6. Code Update: The Click package was updated to 8.1.6 and mypy was allowed to check CLI types by @NolanTrem.

  7. Evaluation Updates: Evaluations were made more modular and extensive, and a database was integrated into evaluations.

  8. Documentation: Instructions for installing poetry were added to the readme, and tips for Windows users were included by @NolanTrem.

  9. Database Changes: Several updates related to database coverage, including a conversation db test and a task w/ db test.

  10. Node Management: @NolanTrem added a new node management feature.

  11. New Contributor: A warm welcome to @voynow who made their first contribution to the project.

For a full list of changes, refer to the complete changelog on the GitHub repository.

New Contributors

Full Changelog: v0.0.4...v0.0.5

v0.0.4

17 Jul 18:38
33cf96c
Compare
Choose a tag to compare

Major Enhancements in Automata v0.0.4

Improved Context Handling, Comprehensive Test Refactor, and Documentation Updates

In this version of Automata, we've introduced a multitude of changes that focus on improving the overall user experience and performance of our codebase:

  • An impressive refactor and improvement of context handling which now provides a more robust context retrieval pipeline.
  • Comprehensive test refactoring and enhancements by NolanTrem, including testing for bounding boxes and tests for singletons, which strengthens the reliability of our system.
  • Significant updates to our documentation along with attempts to streamline our document generation process. We've also improved our 'contributing.md' file to offer a better contribution experience.
  • Several method conversions to properties for better encapsulation and refactoring of context processing.
  • Various bug fixes and patches, including issues with isort-black and regression fixes.
  • Dependency updates brought to you by our friendly bot, dependabot, ensuring our code remains up-to-date and secure.
  • We've also welcomed new contributors, @gravitronics and @sourcery-ai, to the team!

Full Changelog: v0.0.3...v0.0.4

v0.0.3

12 Jul 20:42
c5a2bf2
Compare
Choose a tag to compare

Overview

The latest release of Automata brings some major changes and improvements that aim to enhance efficiency and functionality. The introduction of ChromaDB is a significant highlight of this release, enhancing the project's database capabilities. Additionally, by separating data into a different GitHub repository, the project's organization has become more streamlined and manageable. The removal of RedBaron and unused tools such as PyWriter and PyReader has been completed to further reduce clutter and improve the project's efficiency. Lastly, the project was significantly refactored to continue work on iteratively improving organization and layout.

Another key aspect of this release is the wonderful contributions made by new developers, leading to an increase in test coverage and the overall robustness of the system. This release also saw the adoption of poetry and Docker, both tools that contribute to automating and streamlining development processes. There have been numerous pull requests that contributed to these updates, including changes to the search demo, refreshing search, and bumping of dependencies like pandas, numpy, matplotlib, pygithub, and pydantic. One extensive improvement made by contributor @bhavitsharma was the initial work on replacing RedBaron with Python's ast module inside the module loader.

Lastly, @NolanTrem introduced the usage of poetry and Docker in the project, signifying a positive step towards a more structured and containerized development environment. The project also saw the elimination of old examples and renaming of notebooks, signifying a continued focus on keeping the project relevant and easily understandable.

New Contributors

What's Changed

Full Changelog: v0.0.2...v0.0.3

Second Release - v0.0.2 Pre-release

06 Jul 02:42
a238961
Compare
Choose a tag to compare

At a high level, the recent contributions are a large refactor to help downstream readability and further work on the automatic document generation pipeline.

This involved adding more abstractions around LLM consumption and agent initialization. This also involved reducing the coupling across modules.

I recommend to everyone following along to take a new look at the docs.

Up next, we will be working on generalizing the work we have done thus far on the indexing and graphing so that it can readily work on all major open source repositories.

What's Changed

New Contributors

  • @Exarchias made their first contribution in #116
  • @dependabot made their first contribution in #63

Full Changelog: v0.0.1...v0.0.2

First Release - v0.0.1

29 Jun 18:22
cc47d91
Compare
Choose a tag to compare
Pre-release

Automata's objective is to evolve into a fully autonomous, self-programming Artificial Intelligence system.

This project is inspired by the theory that code is essentially a form of memory, and when furnished with the right tools, AI can evolve real-time capabilities which can potentially lead to the creation of AGI. The word automata comes from the Greek word αὐτόματος, denoting "self-acting, self-willed, self-moving,", and Automata theory is the study of abstract machines and automata, as well as the computational problems that can be solved using them. More information follows below

# Run a single agent w/ trivial instruction
automata run-agent --instructions="Return true" --model=gpt-3.5-turbo-0613

# Run a single agent w/ a non-trivial instruction
automata run-agent --instructions="Explain what AutomataAgent is and how it works, include an example to initialize an instance of AutomataAgent." --model=gpt-3.5-turbo-16k

Sometimes the best way to understand a complicated system is to start by understanding a basic example. The following example illustrates how to run your own Automata agent. The agent will be initialized with a trivial instruction, and will then attempt to write code to fulfill the instruction. The agent will then return the result of its attempt.

import logging
from typing import Any, Set

from automata.config.base import AgentConfigName
from automata.config.openai_agent import AutomataOpenAIAgentConfigBuilder
from automata.core.agent.agents import AutomataOpenAIAgent
from automata.core.agent.tool.tool_utils import AgentToolFactory, DependencyFactory
from automata.core.base.agent import AgentToolProviders
from automata.core.base.github_manager import GitHubManager
from automata.core.coding.py.module_loader import py_module_loader

logger = logging.getLogger(__name__)

# Initialize the module loader
py_module_loader.initialize()


# Construct the set of all dependencies that will be used to build the tools
tool_list = ["context_oracle"]
dependencies: Set[Any] = set()
tool_dependencies = {}

for tool in tool_list:
    for dependency_name, _ in AgentToolFactory.TOOLKIT_TYPE_TO_ARGS[AgentToolProviders(tool)]:
        if dependency_name not in dependencies:
            dependencies.add(dependency_name)
            logger.info(f"  - Building Dependency {dependency_name}...")
            tool_dependencies[dependency_name] = DependencyFactory().get(dependency_name)

# Build the tools
tools = AgentToolFactory.build_tools(tool_list, **tool_dependencies)

# Build the agent config
config_name = AgentConfigName("automata_main")

agent_config = (
    AutomataOpenAIAgentConfigBuilder.from_name(config_name)
    .with_tools(tools)
    .with_model("gpt-4")
    .build()
)

# Initialize the agent
instructions = "Explain how embeddings are used by the codebase"
agent = AutomataOpenAIAgent(instructions, config=agent_config)

# Run the agent
result = agent.run()