docs: update readme

README.md

@@ -2,8 +2,9 @@
 🚀 LangGraph for Swift. A library for building stateful, multi-actor applications with LLMs, developed to work with [LangChain-Swift]. 
 > It is a porting of original [LangGraph] from [LangChain AI project][langchain.ai] in Swift fashion
 
+## Quick Start 
 
-## Adding LangGraph for Swift as a Dependency
+### Adding LangGraph for Swift as a Dependency
 
 To use the LangGraph for Swift library in a [SwiftPM] project, add the following line to the dependencies in your `Package.swift` file:
 
@@ -20,6 +21,39 @@ Include `LangGraph` as a dependency for your executable target:
 
 Finally, add `import LangGraph` to your source code.
 
+### Define the agent state
+
+The main type of graph in `langgraph` is the `StatefulGraph`. This graph is parameterized by a state object that it passes around to each node. Each node then returns operations to update that state. These operations can either SET specific attributes on the state (e.g. overwrite the existing values) or ADD to the existing attribute. Whether to set or add is denoted by initialize the property with a `AppendableValue`. The State must be compliant with `AgentState` protocol that essentially is a Dictionary wrapper
+
+```Swift
+public protocol AgentState {
+
+    var data: [String: Any] { get }
+
+    init( _ initState: [String: Any] )
+}
+```
+
+### Define the nodes
+
+We now need to define a few different nodes in our graph. In langgraph, a node is a function that accept an `AgentState` as argument. There are two main nodes we need for this:
+
+1. **The agent**: responsible for deciding what (if any) actions to take.
+1. **A function to invoke tools**: if the agent decides to take an action, this node will then execute that action.
+
+### Define Edges
+
+We will also need to define some edges. Some of these edges may be conditional. The reason they are conditional is that based on the output of a node, one of several paths may be taken. The path that is taken is not known until that node is run (the LLM decides).
+
+1. **Conditional Edge**: after the agent is called, we should either:
+    * If the agent said to take an action, then the function to invoke tools should be called
+    * If the agent said that it was finished, then it should finish
+1. **Normal Edge**: after the tools are invoked, it should always go back to the agent to decide what to do next
+
+### Define the graph
+
+We can now put it all together and define the graph! (see example below)
+
 ## Integrate with LangChain for Swift
 
 In the [LangChainDemo](LangChainDemo) project, you can find the porting of [AgentExecutor] from [LangChain Swift project][langchain.ai] using LangGraph. Below you can find a piece of code of the `AgentExecutor` to give you an idea of how to use it.