diff --git a/docs/api/index.md b/docs/api/index.md deleted file mode 100644 index e69de29b..00000000 diff --git a/mintlify/concepts.mdx b/docs/concepts.mdx similarity index 100% rename from mintlify/concepts.mdx rename to docs/concepts.mdx diff --git a/docs/concepts/agents.md b/docs/concepts/agents.md deleted file mode 100644 index fadca68a..00000000 --- a/docs/concepts/agents.md +++ /dev/null @@ -1,84 +0,0 @@ -# Agents - -In the ControlFlow framework, an `Agent` represents an AI entity capable of performing tasks and interacting with other agents to achieve desired outcomes. Agents are powered by specialized AI models that excel at specific tasks, such as text generation, decision-making based on unstructured data, or engaging in interactive conversations. - -## The Role of Agents in ControlFlow - -Agents play a crucial role in the execution of tasks within the ControlFlow framework. When a task is defined and added to a workflow, it is assigned to one or more agents responsible for completing the task based on the provided objectives, instructions, and context. - -ControlFlow treats agents as autonomous entities with their own knowledge, capabilities, and tools. By assigning tasks to agents and allowing them to collaborate and communicate with each other, ControlFlow enables the creation of complex AI-powered workflows that can adapt to different scenarios and requirements. - -## Defining Agents - -To create an agent in ControlFlow, you can use the `Agent` class, which provides a flexible way to define an agent's properties and capabilities. - -```python -from controlflow import Agent - -writer_agent = Agent( - name="WriterAgent", - description="An AI agent specializing in creative writing tasks.", - tools=[generate_text, summarize_text], - user_access=False -) -``` - -In this example, we define an agent named "WriterAgent" with a description of its specialization. We also specify the tools available to the agent, which are functions or callable objects that the agent can use to perform specific actions or computations. The `user_access` parameter indicates whether the agent is allowed to interact directly with human users. - -## Agent Properties - -Agents have several key properties that define their characteristics and capabilities: - -- `name` (str): The name of the agent, used for identification and communication purposes. -- `description` (str, optional): A brief description of the agent's specialization or role. -- `tools` (list[AssistantTool | Callable], optional): A list of tools or functions available to the agent for performing tasks. -- `user_access` (bool, optional): Indicates whether the agent is allowed to interact directly with human users. - -## Assigning Tasks to Agents - -When defining a task using the `Task` class or the `@ai_task` decorator, you can specify the agents responsible for completing the task by setting the `agents` parameter. - -```python -from controlflow import Task - -write_story_task = Task( - objective="Write a short story about a mysterious artifact.", - result_type=str, - agents=[writer_agent, editor_agent] -) -``` - -In this example, we assign the "write_story_task" to two agents: "writer_agent" and "editor_agent". These agents will collaborate to complete the task based on their individual capabilities and tools. - -## Agent Execution and Communication - -During the execution of a workflow, agents assigned to tasks take turns performing actions and communicating with each other to progress towards completing the tasks. The `run()` method of a task automatically handles the selection and iteration of agents until the task is complete. - -Agents can communicate with each other by posting messages within the context of a task. These messages are visible to all agents involved in the task and can be used to share information, provide updates, or request assistance. - -```python -from controlflow import Flow - -with Flow(): - story_task = Task( - objective="Write a short story and provide feedback.", - result_type=str, - agents=[writer_agent, editor_agent] - ) - result = story_task.run() -``` - -In this example, the "writer_agent" and "editor_agent" will take turns working on the "story_task". They can communicate with each other by posting messages within the task's context, allowing them to collaborate and provide feedback until the task is complete. - -## Agent Tools and User Access - -Agents can be equipped with tools, which are functions or callable objects that provide additional capabilities or actions that the agent can perform. These tools can be used by the agent during task execution to perform specific computations, access external resources, or interact with other systems. - -The `user_access` property of an agent determines whether the agent is allowed to interact directly with human users. If `user_access` is set to `True`, the agent can use special tools, such as `talk_to_human()`, to send messages to and receive input from human users. This feature is useful for tasks that require human feedback or intervention. - - -## Conclusion - -Agents are a fundamental concept in the ControlFlow framework, representing the AI entities responsible for executing tasks and collaborating to achieve desired outcomes. By defining agents with specific capabilities, tools, and user access permissions, and assigning them to tasks within a workflow, you can create powerful and adaptable AI-powered applications. - -ControlFlow provides a flexible and intuitive way to orchestrate the interaction between agents and tasks, enabling developers to focus on defining the objectives and dependencies of their workflows while the framework handles the complexities of agent coordination and communication. \ No newline at end of file diff --git a/docs/concepts/flows.md b/docs/concepts/flows.md deleted file mode 100644 index a4c641cb..00000000 --- a/docs/concepts/flows.md +++ /dev/null @@ -1,70 +0,0 @@ -# Flows - -In the ControlFlow framework, a `Flow` represents a container for an AI-enhanced workflow. It serves as the top-level object that encapsulates tasks, agents, tools, and context, providing a structured environment for AI-powered applications. - -## The Role of Flows - -Flows play a crucial role in organizing and managing the execution of AI-powered workflows. They provide a high-level abstraction for defining the overall structure and dependencies of tasks, agents, and tools, allowing developers to focus on the desired outcomes rather than the low-level details of agent coordination and communication. - -Key aspects of flows include: - -- **Task Management**: Flows contain a collection of tasks that define the discrete objectives and goals of the workflow. Tasks can be added to a flow explicitly or implicitly through the use of the `@ai_task` decorator or the `Task` class. - -- **Agent Coordination**: Flows manage the assignment and orchestration of agents to tasks. By default, flows are initialized with a default agent, but custom agents can be specified to handle specific tasks or parts of the workflow. - -- **Tool Management**: Flows provide a centralized place to define and manage tools that are available to agents throughout the workflow. Tools can be functions or callable objects that agents can use to perform specific actions or computations. - -- **Context Sharing**: Flows maintain a consistent context across tasks and agents, allowing for seamless sharing of information and state throughout the workflow. The flow's context can be accessed and modified by tasks and agents, enabling dynamic and adaptive behavior. - -## Creating a Flow - -To create a flow, you can use the `@flow` decorator on a Python function. The decorated function becomes the entry point for the AI-powered workflow. - -```python -from controlflow import flow - -@flow -def my_flow(): - # Define tasks, agents, and tools here - ... -``` - -Alternatively, you can create a flow object directly using the `Flow` class: - -```python -from controlflow import Flow - -flow = Flow() -``` - -## Flow Properties - -Flows have several key properties that define their behavior and capabilities: - -- `thread` (Thread): The thread associated with the flow, which stores the conversation history and context. -- `tools` (list[AssistantTool | Callable]): A list of tools that are available to all agents in the flow. -- `agents` (list[Agent]): The default agents for the flow, which are used for tasks that do not specify agents explicitly. -- `context` (dict): Additional context or information that is shared across tasks and agents in the flow. - -## Running a Flow - -To run a flow, you can simply call the decorated function: - -```python -@flow -def my_flow(): - # Define tasks, agents, and tools here - ... - -my_flow() -``` - -When a flow is run, it executes the defined tasks, assigning agents and tools as needed. The flow manages the context across agents. - - - -## Conclusion - -Flows are a fundamental concept in the ControlFlow framework, providing a structured and flexible way to define, organize, and execute AI-powered workflows. By encapsulating tasks, agents, tools, and context within a flow, developers can create complex and dynamic applications that leverage the power of AI while maintaining a clear and maintainable structure. - -Flows abstract away the low-level details of agent coordination and communication, allowing developers to focus on defining the desired outcomes and objectives of their workflows. With the `@flow` decorator and the `Flow` class, creating and running AI-powered workflows becomes a straightforward and intuitive process. \ No newline at end of file diff --git a/mintlify/concepts/flows.mdx b/docs/concepts/flows.mdx similarity index 100% rename from mintlify/concepts/flows.mdx rename to docs/concepts/flows.mdx diff --git a/docs/concepts/iteration.md b/docs/concepts/iteration.md deleted file mode 100644 index 834e1050..00000000 --- a/docs/concepts/iteration.md +++ /dev/null @@ -1,85 +0,0 @@ -# Iterative Control - -Iterative control lies at the core of agentic workflows, enabling the creation of dynamic and adaptive AI-powered applications. In traditional approaches, the iterative logic is often deeply nested within monolithic AI models, making it challenging to understand, customize, and maintain. ControlFlow takes a different approach by elevating iterative control to a first-class citizen in its API, empowering developers to harness the power of iteration with ease and flexibility. - -## The Importance of Iteration in Agentic Workflows - -Agentic workflows are characterized by their ability to make decisions, take actions, and adapt based on feedback and changing conditions. This inherent adaptability is achieved through iteration - the process of repeatedly executing a series of steps until a desired outcome is reached. - -Consider a simple example of an AI-powered task management system. The system needs to continuously monitor incoming tasks, prioritize them based on predefined criteria, assign them to appropriate agents, and track their progress until completion. This workflow requires iterative control to handle the dynamic nature of tasks and to ensure that the system remains responsive and efficient. - -Without iterative control, the system would be limited to handling a fixed set of tasks in a predefined order, lacking the flexibility to adapt to real-world scenarios. Iterative control allows the system to continuously loop through the task management process, making decisions and taking actions based on the current state of tasks and agents. - -## ControlFlow: Making Iterative Control Accessible - -ControlFlow recognizes the critical role of iterative control in agentic workflows and provides a high-level API that makes it accessible and intuitive for developers. By bringing the concept of iteration to the forefront, ControlFlow enables developers to focus on defining the logic and behavior of their workflows, without getting bogged down in low-level implementation details. - -At the heart of ControlFlow's iterative control mechanism lies the `Task` class. A task represents a unit of work that needs to be accomplished by one or more agents. It encapsulates the necessary information, such as the objective, dependencies, and agents responsible for its execution. - -To iterate over tasks, ControlFlow provides the `run()` method. This method abstracts away the underlying while loop, allowing developers to express their workflow logic in a concise and readable manner. Under the hood, `run()` intelligently selects agents, manages dependencies, and orchestrates the execution of tasks until the desired outcome is achieved. - -Here's an example of how iterative control can be achieved using `run()`: - -```python -task = Task(objective="Analyze sales data") -task.run() -``` - -In this example, the `run()` method takes care of the iterative control flow, repeatedly executing the necessary steps until the task is marked as complete. It handles agent selection, dependency resolution, and progress tracking, freeing developers from the complexities of manual iteration. - -## Granular Control with `run_once()` and `agent.run()` - -While `run()` provides a high-level abstraction for iterative control, ControlFlow also offers more granular control options through the `run_once()` method and the `agent.run()` function. - -The `run_once()` method allows developers to take control of the iteration process by executing a single step at a time. It provides the flexibility to inject custom logic, perform additional checks, or handle specific edge cases within each iteration. By combining `while task.is_incomplete()` with `run_once()`, developers can create custom iteration patterns tailored to their specific requirements. - -Here's an example showcasing the usage of `run_once()`: - -```python -while task.is_incomplete(): - task.run_once() - # Perform additional checks or custom logic - if some_condition: - break -``` - -In this example, the `run_once()` method is called repeatedly within a while loop until the task is marked as complete. This granular control enables developers to incorporate custom logic, such as breaking out of the loop based on certain conditions or performing additional actions between iterations. - -For even more fine-grained control, ControlFlow provides the `agent.run()` function. This function allows developers to explicitly invoke a specific agent to execute a task, bypassing the automated agent selection process. It gives developers complete control over which agent handles a particular task and enables them to create custom agent orchestration patterns. - -Here's an example demonstrating the usage of `agent.run()`: - -```python -agent1 = Agent(name="DataAnalyst") -agent2 = Agent(name="ReportGenerator") - -task1 = Task(objective="Analyze sales data") -task2 = Task(objective="Generate sales report") - -agent1.run(task1) -agent2.run(task2) -``` - -In this example, `agent1` is explicitly assigned to execute `task1`, while `agent2` is assigned to execute `task2`. This level of control is particularly useful when dealing with specialized agents or when implementing complex workflows that require precise agent assignment. - -## Balancing Simplicity and Control - -One of the key strengths of ControlFlow is its ability to provide a high-level API for iterative control without sacrificing the ability to dive into lower-level details when needed. The framework strikes a balance between simplicity and control, catering to the needs of both rapid development and fine-grained customization. - -Developers can start by using the high-level `run()` method to quickly prototype and iterate on their workflows. As their requirements grow more complex, they can gradually transition to using `run_once()` and `agent.run()` to incorporate custom logic and take control of the iteration process. - -This gradual descent into lower-level control is made possible by ControlFlow's thoughtful API design. The lower-level methods, such as `run_once()` and `agent.run()`, are not buried deep within the framework but are readily accessible as part of the public API. This accessibility ensures that developers can seamlessly transition between different levels of control without having to navigate through complex abstractions or modify the underlying framework. - -Moreover, even at the lowest level of control, ControlFlow maintains a relatively high level of abstraction compared to traditional approaches. Developers can focus on expressing their workflow logic using intuitive concepts like tasks, agents, and dependencies, rather than dealing with raw loops, conditionals, and state management. - -This balance between simplicity and control empowers developers to build sophisticated agentic workflows without getting overwhelmed by complexity. It enables them to start simple, iterate quickly, and gradually introduce more advanced control mechanisms as their understanding of the problem domain grows. - -## Conclusion - -Iterative control is the driving force behind agentic workflows, enabling the creation of dynamic, adaptive, and intelligent AI-powered applications. ControlFlow recognizes the importance of iteration and provides a high-level API that makes it accessible and intuitive for developers. - -By offering a spectrum of control options, from the high-level `run()` method to the more granular `run_once()` and `agent.run()` functions, ControlFlow empowers developers to choose the level of control that best suits their needs. Whether they prefer the simplicity of automatic iteration or the precision of manual control, ControlFlow provides a seamless and expressive way to build iterative workflows. - -As developers explore the capabilities of ControlFlow, they can leverage the power of iterative control to create sophisticated agentic systems. They can start with the high-level abstractions, gradually diving into lower-level control mechanisms as their requirements evolve. This progressive approach to iterative control enables developers to build robust, adaptive, and maintainable AI-powered workflows. - -With ControlFlow, the iterative control flow is no longer an obscure concept hidden within monolithic models but a central and accessible part of the development process. By embracing the power of iteration and leveraging ControlFlow's intuitive API, developers can unlock the full potential of agentic workflows and create intelligent, dynamic, and efficient AI-powered applications. \ No newline at end of file diff --git a/mintlify/concepts/tasks.mdx b/docs/concepts/tasks.mdx similarity index 100% rename from mintlify/concepts/tasks.mdx rename to docs/concepts/tasks.mdx diff --git a/docs/contributing.md b/docs/contributing.md deleted file mode 100644 index e69de29b..00000000 diff --git a/docs/examples/index.md b/docs/examples/index.md deleted file mode 100644 index e69de29b..00000000 diff --git a/mintlify/favicon.jpeg b/docs/favicon.jpeg similarity index 100% rename from mintlify/favicon.jpeg rename to docs/favicon.jpeg diff --git a/docs/getting_started.md b/docs/getting_started.md deleted file mode 100644 index e69de29b..00000000 diff --git a/mintlify/glossary/agentic-workflow.mdx b/docs/glossary/agentic-workflow.mdx similarity index 100% rename from mintlify/glossary/agentic-workflow.mdx rename to docs/glossary/agentic-workflow.mdx diff --git a/mintlify/glossary/flow-engineering.mdx b/docs/glossary/flow-engineering.mdx similarity index 100% rename from mintlify/glossary/flow-engineering.mdx rename to docs/glossary/flow-engineering.mdx diff --git a/mintlify/glossary/flow-orchestration.mdx b/docs/glossary/flow-orchestration.mdx similarity index 100% rename from mintlify/glossary/flow-orchestration.mdx rename to docs/glossary/flow-orchestration.mdx diff --git a/mintlify/glossary/flow.mdx b/docs/glossary/flow.mdx similarity index 100% rename from mintlify/glossary/flow.mdx rename to docs/glossary/flow.mdx diff --git a/mintlify/glossary/glossary.mdx b/docs/glossary/glossary.mdx similarity index 100% rename from mintlify/glossary/glossary.mdx rename to docs/glossary/glossary.mdx diff --git a/mintlify/glossary/prompt-engineering.mdx b/docs/glossary/prompt-engineering.mdx similarity index 100% rename from mintlify/glossary/prompt-engineering.mdx rename to docs/glossary/prompt-engineering.mdx diff --git a/mintlify/glossary/task-orchestration.mdx b/docs/glossary/task-orchestration.mdx similarity index 100% rename from mintlify/glossary/task-orchestration.mdx rename to docs/glossary/task-orchestration.mdx diff --git a/mintlify/glossary/task.mdx b/docs/glossary/task.mdx similarity index 100% rename from mintlify/glossary/task.mdx rename to docs/glossary/task.mdx diff --git a/mintlify/glossary/workflow.mdx b/docs/glossary/workflow.mdx similarity index 100% rename from mintlify/glossary/workflow.mdx rename to docs/glossary/workflow.mdx diff --git a/docs/guides/best_practices.md b/docs/guides/best_practices.md deleted file mode 100644 index 481e0915..00000000 --- a/docs/guides/best_practices.md +++ /dev/null @@ -1,11 +0,0 @@ -# Best Practices - -## Designing workflows -- Break down sequences into discrete tasks, even if they could be sent as a single prompt to an LLM. This forces the LLM to output intermediate results, which enhance the quality of the final output. This is akin to implementing "chain of thoughts" or similar techniques, but in a more controllable way. -- Use the task objective to describe the desired output; use task instructions to provide context and constraints. This helps the LLM understand the goal and the constraints it should adhere to. -- If your workflow will be provided to another agent as a tool, make sure to run it in a separate flow. Otherwise, it will attempt to interact with the main thread, which is locked by the calling agent. - -## Designing tasks - -## Agents -- An agent's `name` and `description` are visible to all other agents; its `instructions` are private and only visible to itself. \ No newline at end of file diff --git a/docs/guides/index.md b/docs/guides/index.md deleted file mode 100644 index e69de29b..00000000 diff --git a/docs/index.md b/docs/index.md deleted file mode 100644 index c2707b53..00000000 --- a/docs/index.md +++ /dev/null @@ -1,97 +0,0 @@ -# ControlFlow - -**ControlFlow is a framework for building agentic LLM workflows.** - -LLMs are powerful AI models that can understand and generate human-like text, enabling them to perform a wide range of tasks. However, building applications with LLMs can be challenging due to their complexity, unpredictability, and potential for hallucinating or generating irrelevant outputs. - -ControlFlow provides a structured and intuitive way to create sophisticated agentic workflows while adhereing to traditional software engineering best practices. The resulting applications are observable, controllable, and easy to trust. - - -!!! question "What's an agentic workflow?" - An agentic workflow treats LLMs as autonomous entities capable of making decisions and performing complex tasks through iterative interactions. At least some of the workflow logic is carried out by the LLMs themselves. - - -## Design principles -ControlFlow's design is informed by a strong opinion: LLMs are powerful tools, but they are most effective when applied to small, well-defined tasks within a structured workflow. This approach mitigates many of the challenges associated with LLMs, such as hallucinations, biases, and unpredictable behavior, while also making it easier to debug, monitor, and control the application. - -This belief leads to three core design principles that underpin ControlFlow's architecture: - -### 🛠️ Specialized over generalized -ControlFlow advocates for the use of **specialized, single-purpose LLMs** rather than monolithic models that try to do everything. By assigning specific tasks to purpose-built models, ControlFlow ensures that the right tool is used for each job, leading to more efficient, cost-effective, and higher-quality results. - -### 🎯 Outcome over process -ControlFlow embraces a **declarative approach to defining AI workflows**, allowing developers to focus on the desired outcomes rather than the intricacies of steering LLM behavior. By specifying tasks and their requirements using intuitive constructs, developers can express what needs to be done without worrying about the details of how it will be accomplished. - -### 🎛️ Control over autonomy -ControlFlow recognizes the importance of balancing AI capabilities with traditional software development practices. Instead of relying on end-to-end AI systems that make all workflow decisions autonomously, ControlFlow allows as much or as little AI participation as needed, ensuring that developers **maintain visibility and control** over their applications. - - - -## Why ControlFlow? -The three design principles of ControlFlow lead to a number of key features that make it a powerful tool for building AI-powered applications: - -### 🧩 Task-centric architecture -ControlFlow breaks down AI workflows into discrete, self-contained tasks, each with a specific objective and set of requirements. This declarative, modular approach lets developers focus on the high-level logic of their applications while allowing the framework to manage the details of coordinating agents and data flow between tasks. - -### 🕵️ Agent orchestration -ControlFlow's runtime engine handles the orchestration of specialized AI agents, assigning tasks to the most appropriate models and managing the flow of data between them. This orchestration layer abstracts away the complexities of coordinating multiple AI components, allowing developers to focus on the high-level logic of their applications. - -### 🔍 Native debugging and observability -ControlFlow prioritizes transparency and ease of debugging by providing native tools for monitoring and inspecting the execution of AI tasks. Developers can easily track the progress of their workflows, identify bottlenecks or issues, and gain insights into the behavior of individual agents, ensuring that their AI applications are functioning as intended. - -### 🤝 Seamless integration -ControlFlow is designed to integrate seamlessly with existing Python codebases, treating AI tasks as first-class citizens in the application logic. The `Task` class provides a clean interface for defining the inputs, outputs, and requirements of each task, making it easy to incorporate AI capabilities into traditional software workflows. This seamless integration allows for a gradual and controlled adoption of AI, reducing the risk and complexity of introducing AI into existing systems. - -Together, these features make ControlFlow a powerful and flexible framework for building AI-powered applications that are transparent, maintainable, and aligned with software engineering best practices. - - -## Key concepts - -### 🌊 Flow -Flows are containers for agentic workflows, and maintain consistent context and history across all of their tasks. - -### 🚦 Task -Tasks represent discrete objectives for agents to solve. By specifing the expected inputs and outputs, as well as any additional tools, instructions, or collaborators, tasks provide a clear structure for agents to follow. Completing its tasks is the primary objective of a ControlFlow agent. - -### 🤖 Agent -AI agents are assigned to tasks and responsible for completing them. Each agent is designed to be "single-serving," optimized only for completing its task in cooperation with other agents and the broader workflow. - -## Why not "super-agents"? - -Many agentic LLM frameworks rely on monolithic "super-agents": powerful, unconstrained models that are expected to achieve their goals by autonomously handling a wide range of tasks, tools, and behaviors. The resulting workflows are opaque, unpredictable, and difficult to debug. - -This approach naively assumes that the technology is more advanced than it actually is. LLMs feel like magic because they can perform a wide variety of non-algorithmic tasks, but they are still fundamentally limited when it comes to generalizing beyond their traning data and techniques. Moreover, the failure modes of agentic LLMs are difficult to identify, let alone fix, making them difficult to trust in production environments or with mission-critical tasks. - -In contrast to these "super-agent" approaches, ControlFlow promotes a modular, decoupled architecture where specialized agents are orchestrated to perform well-defined tasks, after which traditional software regains control of the application. This approach results in workflows that are more transparent, controllable, and debuggable, setting ControlFlow apart from other frameworks. - - -## Use cases -ControlFlow can be applied to a wide range of use cases, including: - -- Building chatbots and conversational AI systems -- Automating content generation and summarization -- Developing AI-powered research and analysis tools -- Creating intelligent data processing pipelines -- Enhancing existing applications with AI capabilities -- -## Getting started - -To get started with ControlFlow, install it using pip: - -```bash -pip install controlflow -``` - -Check out the [Quickstart](quickstart.md) guide for a step-by-step walkthrough of creating your first ControlFlow application. - -## Dive deeper - -- Explore the [Concepts](concepts/index.md) section to learn more about the core components of ControlFlow. -- Refer to the [API Reference](api/index.md) for detailed information on the classes and functions provided by the framework. -- Browse the [Examples](examples/index.md) to see ControlFlow in action across various use cases. - -## Get involved - -ControlFlow is an open-source project, and we welcome contributions from the community. If you encounter a bug, have a feature request, or want to contribute code, please visit our [GitHub repository](https://github.com/jlowin/controlflow). - -Join our [community forum](https://github.com/jlowin/controlflow/discussions) to ask questions, share your projects, and engage with other ControlFlow users and developers. diff --git a/mintlify/installation.mdx b/docs/installation.mdx similarity index 100% rename from mintlify/installation.mdx rename to docs/installation.mdx diff --git a/mintlify/introduction.mdx b/docs/introduction.mdx similarity index 100% rename from mintlify/introduction.mdx rename to docs/introduction.mdx diff --git a/mintlify/logo/logo.jpeg b/docs/logo/logo.jpeg similarity index 100% rename from mintlify/logo/logo.jpeg rename to docs/logo/logo.jpeg diff --git a/mintlify/mint.json b/docs/mint.json similarity index 100% rename from mintlify/mint.json rename to docs/mint.json diff --git a/mintlify/quickstart.mdx b/docs/quickstart.mdx similarity index 100% rename from mintlify/quickstart.mdx rename to docs/quickstart.mdx diff --git a/pyproject.toml b/pyproject.toml index 9b33854e..ed18ea4a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -43,13 +43,7 @@ tests = [ "pytest-xdist", "pre-commit>=3.7.0", ] -dev = [ - "controlflow[tests]", - "ipython>=8.22.2", - "pdbpp>=0.10.3", - "ruff>=0.3.4", - "mkdocs-material>=9.5.21", -] +dev = ["controlflow[tests]", "ipython>=8.22.2", "pdbpp>=0.10.3", "ruff>=0.3.4"] [build-system] requires = ["hatchling"] diff --git a/requirements-dev.lock b/requirements-dev.lock index cf3d8e5c..b6f2a16f 100644 --- a/requirements-dev.lock +++ b/requirements-dev.lock @@ -220,8 +220,8 @@ markupsafe==2.1.5 # via mkdocs-autorefs # via mkdocstrings # via werkzeug -marvin @ git+https://github.com/prefecthq/marvin@8c0c083aab5c9c2ca6f800fd392bef2a5d3dd9ca - # via control-flow +marvin @ git+https://github.com/prefecthq/marvin@aedfb9573e5f0844a1dc1b45b59d279524b0d363 + # via controlflow matplotlib-inline==0.1.6 # via ipython mdurl==0.1.2 @@ -301,8 +301,8 @@ pluggy==1.4.0 # via pytest pre-commit==3.7.0 # via prefect -prefect @ git+https://github.com/prefecthq/prefect@3f5d6afbc4e1b5cea416c64d28e4b6feb7c2d656 - # via control-flow +prefect @ git+https://github.com/prefecthq/prefect@8454a1c8938bdd1204eefbdb3606129e37501653 + # via controlflow prompt-toolkit==3.0.43 # via ipython # via marvin @@ -322,7 +322,7 @@ pyasn1-modules==0.4.0 pycparser==2.22 # via cffi pydantic==2.6.4 - # via control-flow + # via controlflow # via fastapi # via marvin # via openai diff --git a/requirements.lock b/requirements.lock index c261dff4..6471f101 100644 --- a/requirements.lock +++ b/requirements.lock @@ -220,8 +220,8 @@ markupsafe==2.1.5 # via mkdocs-autorefs # via mkdocstrings # via werkzeug -marvin @ git+https://github.com/prefecthq/marvin@8c0c083aab5c9c2ca6f800fd392bef2a5d3dd9ca - # via control-flow +marvin @ git+https://github.com/prefecthq/marvin@aedfb9573e5f0844a1dc1b45b59d279524b0d363 + # via controlflow matplotlib-inline==0.1.7 # via ipython mdurl==0.1.2 @@ -301,8 +301,8 @@ pluggy==1.5.0 # via pytest pre-commit==3.7.1 # via prefect -prefect @ git+https://github.com/prefecthq/prefect@3f5d6afbc4e1b5cea416c64d28e4b6feb7c2d656 - # via control-flow +prefect @ git+https://github.com/prefecthq/prefect@8454a1c8938bdd1204eefbdb3606129e37501653 + # via controlflow prompt-toolkit==3.0.43 # via ipython # via marvin @@ -322,7 +322,7 @@ pyasn1-modules==0.4.0 pycparser==2.22 # via cffi pydantic==2.6.4 - # via control-flow + # via controlflow # via fastapi # via marvin # via openai