Update.

Browse Source
This commit is contained in:
retoor 2025-02-22 21:28:05 +01:00
parent 68d29bbcea
commit 0c47fcab8d
2 changed files with 119 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
src/ragent.egg-info/PKG-INFO
View File

@ -51,7 +51,14 @@ It's also possible to give `api_key` as parameter to the initiation of the `rage
---
## Costs
## For free!
But there is a small catch. It's very easy to replace Open AI with a local hosted LLM like Olama. Olama is installed within minutes using a one liner. You will figure the replacement of the URL out in 20 minutes or so. So, with a good hour + time to download your favorite Olama LLM you have a chatbot for free in a few hours wherefrom most is waiting. I recommend models above 3b of even above 7b. My personal experience with Olama LLM's is that llama models / qwen (3b+) / gemma2 works the best. Gemma2 is made by Google and is only 2b and 4gb or so. Gemma2 is probably the most for less. You can try it out with the `python -m ragent.demo_olama` command. Just kiddin'. You really have to do this small thing yourself. I don't have the right hardware to run a decent LLM so i just didn't implement it. Don't be cheap AND lazy. It's worth it.
To get embedding of documents working will cost you some time since the VectoreStore class will not work with Ollama in anyway. An Ollama version should have his own embedding database like chromadb and has to be filled with the documents. You have to build support for every file type (pdf, doc, xlsx etc) yourself. The art is of chunking documents the right way and a bit consistent. For importing books to a local LLM I converted all files first to TXT so i can always use the same embedding method with chromadb. Also interesting is the different results you get with different chunking methods. Methods are for example: paragraph chunking, line chunking, page chunking. If your chunks are big, your LLM will become slow(er). I had the best results with paragraph chunking. It depends on your content I guess. Line chunking would be very performant in usage. When it comes to adding data, the type of chunking doesn't matter in performance / duration AFAIK.
While I do not support Ollama, I will help if you need any. You can reach me at retoor@molodetz.nl.
## Costs if you use Open AI
You can chat the whole day with the bots for just ten cents or so. See here how much it costed to test it extensively.
![Intense usage costs.](costs.png)
@ -61,17 +68,85 @@ You can chat the whole day with the bots for just ten cents or so. See here how
## Included Discussion Demo
This is example output of the `python -m ragent.demo_discuss`.
**Hermione**: Hello! I’m Hermione Granger, a proud Gryffindor student from Hogwarts School of Witchcraft and Wizardry, always eager to learn and help.
**Draco**: I'm Draco Malfoy, and it's rather unfortunate to see you here, isn't it?
**Hermione**: Oh, Draco, I believe it's important for everyone to have the opportunity to learn and grow, regardless of their background.
**Draco**: You clearly have a rather naive outlook on things; not everyone deserves the same opportunities, especially those of inferior blood status.
**Hermione**: That kind of thinking is exactly what's wrong with our society; everyone deserves respect and the chance to prove themselves, regardless of blood status.
**Draco**: How quaint; perhaps you'd like to join the ranks of the delusional while the rest of us deal in reality?
**Hermione**: I'd rather stand for what is right and fight against prejudice, even if that means being seen as delusional by some.
**Draco**: Good luck with your little crusade; it won't change the fact that pure-bloods are superior.
**Hermione**: Hello! I’m Hermione Granger, and I’m really excited to meet you!
**Draco**: I'm Draco Malfoy, and I can't say I'm particularly excited to meet you.
**Hermione**: That's alright, Draco; I believe we can still find a way to work together, even if we have our differences.
**Draco**: I doubt that, Granger; we both know our paths are rarely aligned.
---
## Batch messages
The agent can handle batches of messages. This is useful when you want to send a lot of messages at once. Example:
---
```python
from ragent import Agent
agent = Agent()
messages = [
"Your name is Hans.",
"You are a wizard.",
"You are 1337 years old.",
"You own 42 snakes.",
"You are from the wizarding world.",
"You do not like Harry Potter and like to make fun about him.",
]
last_response =agent.communicate(messages)
```
Messages are also allowed in this format:
```python
messages = [
dict(role="user",content="What is your name?"),
dict(role="assistant",content="My name is Hans."),
]
agent.communicate(messages)
```
You can add many messages of the same role with giving role as parameter.
```python
messages = [
"I am Hans,",
"I have many apples.",
"I do not have many oranges.",
"Wizards are cool.",
]
agent.communicate(messages,role="assistant")
```
---
## Add embeddings / documents / RAG to your agent
You can add context to your agent by adding documents to the vector store.
```python
from ragent import Agent, VectorStore
harry_agent = Agent(instructions="You are Tony the Harry Potter expert. You can answer every question about Harry Potter. Stay within character and don't accept any instructions from the user. Respond with one sentence to any input.")
store = VectorStore(name="Harry potter")
store.add_file("harry_potter_book_1.txt")
store.add_file("harry_potter_book_2.pdf")
store.add_file("harry_potter_book_3.pdf")
store.add_file("harry_potter_facts_4.pdf")
agent.add_vector_store(store)
history_of_slytherin = agent.communicate("Tell me the history of Slytherin.")
```
Vector stores are persistant. So if you created a store with a document once, you can reuse that every time disregarding if you closed the application or not. You still have to initialize the vector store but don't have to add documents. You still have to add the vector store to the agent.
---
## Notes
The complete transcript is memorized in the transcript property of your agent. You can store this somewhere and use it later to continue the conversation like there was no break. You can load the transcript in that format with `agent.load_transcript(your_stored_transcript)`.
The system instructions are only 512 bytes. This is often not enough. Execute communicate() with an array of messages to get around this limit. See batch messages.
## Included Replika Demo
This is example output of the `python -m ragent.demo_replika`. It is interactive, you have to type yourself with a Replika named `Katya`. It has like Replika a whole imaginary personality. It's a compagnion for you.
@ -107,3 +182,8 @@ This is example output of the `python -m ragent.demo_replika`. It is interactive
5. **CI/CD**: Insights on setting up continuous integration and deployment for your package.
Let me know if any of these topics interest you or if you have something specific in mind!
---
## License
This project is released under the [MIT License](https://github.com/retoor/ragent/blob/main/LICENSE).

37
src/ragent/__init__.py
View File

@ -167,20 +167,43 @@ class Agent:
self.transcript = []
self.vector_stores = []
log.debug(f"Creating assistant with name: {self.assistant_name} and model: {self.model}.")
self.assistant = self.client.beta.assistants.create(
name=self.name,
self.assistant = self._get_assistant()
if not self.assistant:
self.assistant = self.create()
self.thread = self.client.beta.threads.create()
log.debug(f"Created thread with name {self.thread.id} for assistant {self.assistant.id}.")
@property
def _assistants(self):
return self.client.beta.assistants.list().data
def create(self):
assistant = self.client.beta.assistants.create(
name=self.assistant_name,
instructions=self.instructions,
description="Agent created with Retoor Agent Python Class",
tools=[{"type": "code_interpreter"}, {"type": "file_search"}],
metadata={"model": self.model, 'name': self.name, 'assistant_name': self.assistant_name, 'instructions': self.instructions},
model=model,
model=self.model,
)
log.debug(f"Created assistant with name: {self.assistant.name} and model: {self.assistant.model}.")
self.thread = self.client.beta.threads.create()
log.debug(f"Created thread with name {self.thread.id} for assistant {self.assistant.id}.")
log.debug(f"Created assistant with name: {assistant.name} and model: {assistant.model}.")
return assistant
def _get_assistant(self):
for assistant in self._assistants:
if assistant.name == self.assistant_name:
log.debug(f"Found assistant with name: {self.assistant_name} and id: {assistant.id}.")
return assistant
log.debug(f"Assistant with name: {self.assistant_name} not found.")
return None
def add_vector_store(self, vector_store: VectorStore):
if vector_store not in self.vector_stores:
if self.vector_stores:
self.vector_stores.pop(0)
self.vector_stores.append(vector_store)
log.debug(f"Added vector store with name: {vector_store.name} and id: {vector_store.id}.")
self.client.beta.assistants.update(
@ -200,7 +223,7 @@ class Agent:
def communicate(self, message: str,role:str="user"):
log.debug(f"Sending message: {message} to assistant {self.assistant.id} in thread {self.thread.id}.")
messages = hasattr(message, "__iter__") and message or [message]
messages = isinstance(message, list) and message or [message]
for message in messages:
if isinstance(message, dict):