• Oct 2024:

  • [0.18.0] LLMConfig.async_stream_quiet flag to turn off LLM output in async + stream mode.
  • [0.17.0] XML-based tools, see docs.

• Sep 2024:

  • 0.16.0 Support for OpenAI o1-mini and o1-preview models.
  • 0.15.0 Cerebras API support -- run llama-3.1 models hosted on Cerebras Cloud (very fast inference).
  • 0.14.0 DocChatAgent uses Reciprocal Rank Fusion (RRF) to rank chunks retrieved by different methods.
  • 0.12.0 run_batch_task new option -- stop_on_first_result - allows termination of batch as soon as any task returns a result.

• Aug 2024:

  • 0.11.0 Polymorphic Task.run(), Task.run_async.
  • 0.10.0 Allow tool handlers to return arbitrary result type, including other tools.
  • 0.9.0 Orchestration Tools, to signal various task statuses, and to pass messages between agents.
  • 0.7.0 OpenAI tools API support, including multi-tools.

• Jul 2024:

  • 0.3.0: Added FastEmbed embeddings from Qdrant

• Jun 2024:

  • 0.2.0: Improved lineage tracking, granular sub-task configs, and a new tool, RewindTool, that lets an agent "rewind and redo" a past message (and all dependent messages are cleared out thanks to the lineage tracking). Read notes here.

• May 2024:

  • Slimmer langroid: All document-parsers (i.e. pdf, doc, docx) and most vector-databases (except qdrant) are now optional/extra dependencies, which helps reduce build size, script start-up time, and install time. For convenience various grouping of "extras" are provided, e.g. doc-chat, db (for database-related dependencies). See updated install instructions below and in the docs.
  • Few-shot examples for tools: when defining a ToolMessage, previously you were able to include a classmethod named examples, and a random example from this list would be used to generate a 1-shot example for the LLM. This has been improved so you can now supply a list of examples where each example is either a tool instance, or a tuple of (description, tool instance), where the description is a "thought" that leads the LLM to use the tool (see example in the docs). In some scenarios this can improve LLM tool generation accuracy. Also, now instead of a random example, ALL examples are used to generate few-shot examples.
  • Infinite loop detection for task loops of cycle-length <= 10 (configurable in TaskConfig. Only detects exact loops, rather than approximate loops where the entities are saying essentially similar (but not exactly the same) things repeatedly.
  • "@"-addressing: any entity can address any other by name, which can be the name of an agent's responder ("llm", "user", "agent") or a sub-task name. This is a simpler alternative to the RecipientTool mechanism, with the tradeoff that since it's not a tool, there's no way to enforce/remind the LLM to explicitly specify an addressee (in scenarios where this is important).
  • Much-Improved Citation generation and display when using DocChatAgent.
  • gpt-4o is now the default LLM throughout; Update tests and examples to work with this LLM; use tokenizer corresponding to the LLM.
  • gemini 1.5 pro support via litellm
  • QdrantDB: update to support learned sparse embeddings.

• Apr 2024:

  • 0.1.236: Support for open LLMs hosted on Groq, e.g. specify chat_model="groq/llama3-8b-8192". See tutorial.
  • 0.1.235: Task.run(), Task.run_async(), run_batch_tasks have max_cost and max_tokens params to exit when tokens or cost exceed a limit. The result ChatDocument.metadata now includes a status field which is a code indicating a task completion reason code. Also task.run() etc can be invoked with an explicit session_id field which is used as a key to look up various settings in Redis cache. Currently only used to look up "kill status" - this allows killing a running task, either by task.kill() or by the classmethod Task.kill_session(session_id). For example usage, see the test_task_kill in tests/main/test_task.py

• Mar 2024:

  • 0.1.216: Improvements to allow concurrent runs of DocChatAgent, see the test_doc_chat_agent.py in particular the test_doc_chat_batch(); New task run utility: run_batch_task_gen where a task generator can be specified, to generate one task per input.
  • 0.1.212: ImagePdfParser: support for extracting text from image-based PDFs. (this means DocChatAgent will now work with image-pdfs).
  • 0.1.194 - 0.1.211: Misc fixes, improvements, and features:
    • Big enhancement in RAG performance (mainly, recall) due to a fix in Relevance Extractor
    • DocChatAgent context-window fixes
    • Anthropic/Claude3 support via Litellm
    • URLLoader: detect file time from header when URL doesn't end with a recognizable suffix like .pdf, .docx, etc.
    • Misc lancedb integration fixes
    • Auto-select embedding config based on whether sentence_transformer module is available.
    • Slim down dependencies, make some heavy ones optional, e.g. unstructured, haystack, chromadb, mkdocs, huggingface-hub, sentence-transformers.
    • Easier top-level imports from import langroid as lr
    • Improve JSON detection, esp from weak LLMs

• Feb 2024:

  • 0.1.193: Support local LLMs using Ollama's new OpenAI-Compatible server: simply specify chat_model="ollama/mistral". See release notes.
  • 0.1.183: Added Chainlit support via callbacks. See examples.

• Jan 2024:

  • 0.1.175
    • Neo4jChatAgent to chat with a neo4j knowledge-graph. (Thanks to Mohannad!). The agent uses tools to query the Neo4j schema and translate user queries to Cypher queries, and the tool handler executes these queries, returning them to the LLM to compose a natural language response (analogous to how SQLChatAgent works). See example script using this Agent to answer questions about Python pkg dependencies.
    • Support for .doc file parsing (in addition to .docx)
    • Specify optional formatter param in OpenAIGPTConfig to ensure accurate chat formatting for local LLMs.
  • 0.1.157: DocChatAgentConfig has a new param: add_fields_to_content, to specify additional document fields to insert into the main content field, to help improve retrieval.
  • 0.1.156: New Task control signals PASS_TO, SEND_TO; VectorStore: Compute Pandas expression on documents; LanceRAGTaskCreator creates 3-agent RAG system with Query Planner, Critic and RAG Agent.

• Dec 2023:

  • 0.1.154: (For details see release notes of 0.1.149 and 0.1.154).
    • DocChatAgent: Ingest Pandas dataframes and filtering.
    • LanceDocChatAgent leverages LanceDB vector-db for efficient vector search and full-text search and filtering.
    • Improved task and multi-agent control mechanisms
    • LanceRAGTaskCreator to create a 2-agent system consisting of a LanceFilterAgent that decides a filter and rephrase query to send to a RAG agent.
  • 0.1.141: API Simplifications to reduce boilerplate: auto-select an available OpenAI model (preferring gpt-4-turbo), simplifies defaults. Simpler Task initialization with default ChatAgent.

• Nov 2023:

  • 0.1.126: OpenAIAssistant agent: Caching Support.

  • 0.1.117: Support for OpenAI Assistant API tools: Function-calling, Code-intepreter, and Retriever (RAG), file uploads. These work seamlessly with Langroid's task-orchestration. Until docs are ready, it's best to see these usage examples:

    • Tests:

      • test_openai_assistant.py
      • test_openai_assistant_async.py

    • Example scripts:

      • The most basic chat app
      • Chat with code interpreter
      • Chat with retrieval (RAG)
      • 2-agent RAG chat

  • 0.1.112: OpenAIAssistant is a subclass of ChatAgent that leverages the new OpenAI Assistant API. It can be used as a drop-in replacement for ChatAgent, and relies on the Assistant API to maintain conversation state, and leverages persistent threads and assistants to reconnect to them if needed. Examples: test_openai_assistant.py, test_openai_assistant_async.py

  • 0.1.111: Support latest OpenAI model: GPT4_TURBO (see test_llm.py for example usage)

  • 0.1.110: Upgrade from OpenAI v0.x to v1.1.1 (in preparation for Assistants API and more); (litellm temporarily disabled due to OpenAI version conflict).

• Oct 2023:

  • 0.1.107: DocChatAgent re-rankers: rank_with_diversity, rank_to_periphery (lost in middle).
  • 0.1.102: DocChatAgentConfig.n_neighbor_chunks > 0 allows returning context chunks around match.
  • 0.1.101: DocChatAgent uses RelevanceExtractorAgent to have the LLM extract relevant portions of a chunk using sentence-numbering, resulting in huge speed up and cost reduction compared to the naive "sentence-parroting" approach (writing out full sentences out relevant whole sentences) which LangChain uses in their LLMChainExtractor.
  • 0.1.100: API update: all of Langroid is accessible with a single import, i.e. import langroid as lr. See the documentation for usage.
  • 0.1.99: Convenience batch functions to run tasks, agent methods on a list of inputs concurrently in async mode. See examples in test_batch.py.
  • 0.1.95: Added support for Momento Serverless Vector Index
  • 0.1.94: Added support for LanceDB vector-store -- allows vector, Full-text, SQL search.
  • 0.1.84: Added LiteLLM, so now Langroid can be used with over 100 LLM providers (remote or local)! See guide here.

• Sep 2023:

  • 0.1.78: Async versions of several Task, Agent and LLM methods; Nested Pydantic classes are now supported for LLM Function-calling, Tools, Structured Output.
  • 0.1.76: DocChatAgent: support for loading docx files (preliminary).
  • 0.1.72: Many improvements to DocChatAgent: better embedding model, hybrid search to improve retrieval, better pdf parsing, re-ranking retrieved results with cross-encoders.
  • Use with local LLama Models: see tutorial here
  • Langroid Blog/Newsletter Launched!: First post is here -- Please subscribe to stay updated.
  • 0.1.56: Support Azure OpenAI.
  • 0.1.55: Improved SQLChatAgent that efficiently retrieves relevant schema info when translating natural language to SQL.

• Aug 2023:

  • Hierarchical computation example using Langroid agents and task orchestration.
  • 0.1.51: Support for global state, see test_global_state.py.
  • 🐳 Langroid Docker image, available, see instructions below.
  • RecipientTool enables (+ enforces) LLM to specify an intended recipient when talking to 2 or more agents. See this test for example usage.
  • Example: Answer questions using Google Search + vecdb-retrieval from URL contents.
  • 0.1.39: GoogleSearchTool to enable Agents (their LLM) to do Google searches via function-calling/tools. See this chat example for how easy it is to add this tool to an agent.
  • Colab notebook to try the quick-start examples:
  • 0.1.37: Added SQLChatAgent -- thanks to our latest contributor Rithwik Babu!
  • Multi-agent Example: Autocorrect chat

• July 2023:

  • 0.1.30: Added TableChatAgent to chat with tabular datasets (dataframes, files, URLs): LLM generates Pandas code, and code is executed using Langroid's tool/function-call mechanism.
  • Demo: 3-agent system for Audience Targeting.
  • 0.1.27: Added support for Momento Serverless Cache as an alternative to Redis.
  • 0.1.24: DocChatAgent now accepts PDF files or URLs.

If you are using SQLChatAgent (e.g. the script examples/data-qa/sql-chat/sql_chat.py), with a postgres db, you will need to:

• Install PostgreSQL dev libraries for your platform, e.g.
  • sudo apt-get install libpq-dev on Ubuntu,
  • brew install postgresql on Mac, etc.
• Install langroid with the postgres extra, e.g. pip install langroid[postgres] or poetry add langroid[postgres] or poetry install -E postgres. If this gives you an error, try pip install psycopg2-binary in your virtualenv.

All of the following environment variable settings are optional, and some are only needed to use specific features (as noted below).

• Qdrant Vector Store API Key, URL. This is only required if you want to use Qdrant cloud. Alternatively Chroma or LanceDB are also currently supported. We use the local-storage version of Chroma, so there is no need for an API key.
• Redis Password, host, port: This is optional, and only needed to cache LLM API responses using Redis Cloud. Redis offers a free 30MB Redis account which is more than sufficient to try out Langroid and even beyond. If you don't set up these, Langroid will use a pure-python Redis in-memory cache via the Fakeredis library.
• Momento Serverless Caching of LLM API responses (as an alternative to Redis). To use Momento instead of Redis:
  • enter your Momento Token in the .env file, as the value of MOMENTO_AUTH_TOKEN (see example file below),
  • in the .env file set CACHE_TYPE=momento (instead of CACHE_TYPE=redis which is the default).
• GitHub Personal Access Token (required for apps that need to analyze git repos; token-based API calls are less rate-limited). See this GitHub page.
• Google Custom Search API Credentials: Only needed to enable an Agent to use the GoogleSearchTool. To use Google Search as an LLM Tool/Plugin/function-call, you'll need to set up a Google API key, then setup a Google Custom Search Engine (CSE) and get the CSE ID. (Documentation for these can be challenging, we suggest asking GPT4 for a step-by-step guide.) After obtaining these credentials, store them as values of GOOGLE_API_KEY and GOOGLE_CSE_ID in your .env file. Full documentation on using this (and other such "stateless" tools) is coming soon, but in the meantime take a peek at this chat example, which shows how you can easily equip an Agent with a GoogleSearchtool.

If you add all of these optional variables, your .env file should look like this:

OPENAI_API_KEY=your-key-here-without-quotes
GITHUB_ACCESS_TOKEN=your-personal-access-token-no-quotes
CACHE_TYPE=redis # or momento
REDIS_PASSWORD=your-redis-password-no-quotes
REDIS_HOST=your-redis-hostname-no-quotes
REDIS_PORT=your-redis-port-no-quotes
MOMENTO_AUTH_TOKEN=your-momento-token-no-quotes # instead of REDIS* variables
QDRANT_API_KEY=your-key
QDRANT_API_URL=https://your.url.here:6333 # note port number must be included
GOOGLE_API_KEY=your-key
GOOGLE_CSE_ID=your-cse-id

When using Azure OpenAI, additional environment variables are required in the .env file. This page Microsoft Azure OpenAI provides more information, and you can set each environment variable as follows:

• AZURE_OPENAI_API_KEY, from the value of API_KEY
• AZURE_OPENAI_API_BASE from the value of ENDPOINT, typically looks like https://your.domain.azure.com.
• For AZURE_OPENAI_API_VERSION, you can use the default value in .env-template, and latest version can be found here
• AZURE_OPENAI_DEPLOYMENT_NAME is the name of the deployed model, which is defined by the user during the model setup
• AZURE_OPENAI_MODEL_NAME Azure OpenAI allows specific model names when you select the model for your deployment. You need to put precisly the exact model name that was selected. For example, GPT-3.5 (should be gpt-35-turbo-16k or gpt-35-turbo) or GPT-4 (should be gpt-4-32k or gpt-4).
• AZURE_OPENAI_MODEL_VERSION is required if AZURE_OPENAI_MODEL_NAME = gpt=4, which will assist Langroid to determine the cost of the model