# Simplifying Ai Agents in Rust 🕵🏼
Espionox is an attempt to make building Ai applications in Rust just as approachable as it is with other libraries such as LangChain.
## Why would I use Espionox?
- Making an LLM application in Rust
- Experimenting with with complex 'prompt flows' such as Chain/Tree of thought
## Getting started
First, you'll want to create an environment.
```
use espionox::environment::Environment;
let env_name = "demo-env";
let api_key: &str = "your-openai-api-key";
let env = Environment::new(Some(env_name), Some(api_key));
```
Once an `Environment` has been instantiated, you can add agents to it
```
use espionox::environment::Agent;
let agent = Agent::default();
let agent_name = "my agent";
let agent_handle = env.insert_agent(Some(agent_name), agent).await.unwrap();
```
When `insert_agent` returns Ok, it will return an `AgentHandler`
After inserting any Agents or EnvListeners run this command to start running the environment:
```
env.spawn().await.unwrap()
```
Once the environment is running, the `AgentHandler` can be used to make completion requests
```
let message = Message::new_user("Hello!");
let ticket = agent_handle.request_io_completion(message).await.unwrap();
```
Get the response to your completion requests with the returned `ticket` UUid
```
let noti = env.notifications.wait_for_notification(&ticket).await.unwrap();
let message: &Message = noti.extract_body().try_into().unwrap();
```
Completions can also be returned as streams if the `request_stream_completion` method is used:
```
let stream_handler: &ThreadSafeStreamCompletionHandler = noti.extract_body().try_into().unwrap();
let mut handler = stream_handler.lock().await;
let mut whole_message = String::new();
while let Some(CompletionStreamStatus::Working(token)) = handler
.receive(&handle.id, environment.clone_sender())
.await
{
whole_message.push_str(&token);
}
println!("GOT WHOLE MESSAGE: {}", whole_message);
```
## Listeners
One of Espionox's best offerings is the EnvListener trait
```
pub trait EnvListener: std::fmt::Debug + Send + Sync + 'static {
/// Returns Some when the listener should be triggered
fn trigger<'l>(&self, env_message: &'l EnvMessage) -> Option<&'l EnvMessage>;
/// method to be called when listener is activated, must return an env message to replace input
fn method<'l>(
&'l mut self,
trigger_message: EnvMessage,
dispatch: &'l mut Dispatch,
) -> ListenerMethodReturn;
}
```
Any struct implementing this trait can be added to an Environment using the `insert_listener` method. EnvListeners can be used to enforce self consistency in creative ways. Check the examples directory for examples of listeners in action.
espionox is very early in development and everything in the API may be subject to change
Please feel free to reach out with any questions, suggestions, issues or anything else :)