0:01 We all know the challenges large
0:03 language models face when it comes to
0:06 context retention. Most of the time they
0:08 struggle to remember important details
0:11 over extended interactions. But now
0:14 there's a new and extremely fast way for
0:16 anyone to build AI agents with reliable
0:19 long-term memory. Not just standard RAG.
0:22 It's an AI memory framework that enables
0:24 large language models to remember,
0:26 understand, and connect information
0:29 across multiple documents. Instead of
0:31 treating each prompt as an isolated
0:33 request, it builds a memory layer
0:35 powered by a knowledge graph that
0:37 captures relationships, entities, and
0:39 [music] context. And this is where I
0:41 would like to introduce Cognney, the
0:43 next generation framework that
0:46 redefineses how AI memory truly works.
0:48 In essence, Cogni brings persistent
0:51 memory to AI agents that allows
0:54 applications to maintain context across
0:55 sessions while seamlessly interacting
0:57 with existing features, which is going
1:00 to make it intelligent contextware
1:02 systems that are easier to build than
1:05 ever before. What's also great is that
1:07 Cogni introduces advanced features that
1:09 make AI memory truly intelligent.
1:12 Starting with me, which automatically
1:14 structures your data into meaningful
1:16 concepts. There's temporal awareness.
1:18 This is where it helps your AI
1:20 understand how information evolves over
1:22 time, giving it context beyond a single
1:25 session. And with the new feedback
1:26 mechanism, your agent learns
1:29 continuously from your inputs, refining
1:31 its understanding just like a human. And
1:34 the best part is is that Cognney is an
1:35 open-source tool that you can easily get
1:38 started with with less than six lines of
1:40 code. This is something that you can
1:42 easily get started by having it
1:45 self-hosted or you can access it through
1:48 the cloud. Now, another way is simply
1:50 accessing it through Google Collab. And
1:53 that way you can test it out to see how
1:55 it performs with a couple of different
1:58 sorts of examples that they have. Just
2:00 take a look at this example as to how
2:02 Cognney brings semantic memory to AI
2:05 agents. We start by installing Cogni and
2:07 setting up a helper class to manage the
2:09 files, preview data, and handle the
2:11 visualizations. Then we create a small
2:13 developer data set which combines a
2:16 short intro coding conversations as well
2:19 as the Zen of Python principles. It also
2:21 includes an ontology file. Next, we
2:23 reset the memory with the prune command.
2:25 And then you can add your data using the
2:27 add command. And then with this, Cognney
2:29 then builds a knowledge graph with
2:32 Cognify. It is going to link the related
2:34 ideas through embeddings. We can also
2:36 visualize the graph to see how our data
2:39 connects, how it searches using natural
2:41 language, and even provide feedback. So,
2:43 Cognney learns and strengthens its
2:46 memory over time. In short, the notebook
2:48 is going to showcase how Cognney turns
2:51 plain text into dynamic variable
2:53 knowledge graphs, giving your AI agent
2:55 real context and recall. This is
2:57 something that you can get started with
2:59 today. And what's nice is that this
3:02 framework has a UI which is featuring
3:05 local and cloud notebooks and a built-in
3:07 graph explorer. So you can easily add
3:10 data, build memory graphs, and query
3:12 your AI memory. So it's easier to work
3:16 with the core ideas for your AI agent
3:19 with this userfriendly UI. But like I'd
3:20 mentioned, if you want to use the cloud
3:22 version, you can easily click on Cogni
3:24 Cloud and then you can sign up with
3:26 account and you can get started with it
3:28 on the web. But say if you want to use
3:30 the self-hosted method, which is
3:32 something that I'll be showcasing, we
3:35 will need to now work on making sure we
3:37 have all the prerequisites fulfilled.
3:40 Make sure you have Python 3.10 to 3.12
3:42 installed. And you can install it using
3:46 UV so it's contained in an environment.
3:48 Then simply go ahead and open up your
3:50 command prompt. And what you can now do
3:53 is copy this command with uv. And then
3:55 you can use the pip install command to
3:58 install all the packages for cogni to be
4:00 functional on your computer. After
4:02 installing, you can then set up the
4:05 basic usage where you set your open AI
4:08 API key or you can use other supported
4:11 providers from Azour open AAI to Google
4:14 Gemini or even local models through
4:16 Olama. Before we get started, I just
4:17 want to mention that you should
4:19 definitely go ahead and subscribe to the
4:21 world of AI newsletter. I'm constantly
4:23 posting different newsletters on a
4:25 weekly basis. So, this is where you can
4:28 easily get up-to-date knowledge about
4:30 what is happening in the AI space. So,
4:32 definitely go ahead and subscribe as
4:34 this is completely for free. But now we
4:37 can start working with Cognney via CLI
4:38 or through the UI which is something
4:40 that we'll showcase in a second. For
4:42 example, we can get started with the
4:45 basic commands like Cognney CLI and then
4:46 the next function which is to add
4:48 something to the memory layer. So for
4:51 example, you're giving Cogni some text
4:53 or some documents to remember. You can
4:55 use the add function for that and then
4:56 you can paste this within your terminal
4:59 and you can click on enter. This will
5:01 only work if you have Cogni installed as
5:04 well as have it linked to an API. So
5:05 right now it is adding it to the
5:07 database storage and you can see that it
5:10 has now ingested that context. Now what
5:13 you can also do is use the cognify
5:15 command. This is where cogni will
5:18 process the data that you have added and
5:19 it will build a structured knowledge
5:21 graph. This is where the relationships
5:24 between concepts are inferred and
5:26 stored. So now we can go back into the
5:29 terminal and paste this cognify command
5:32 within and it'll work on processing the
5:34 data for us. Now what we can do is use
5:36 the search function and this is where we
5:38 can actually query the knowledge graph
5:41 and return relevant information. It's
5:43 super simple guys. This is how easy
5:45 Cogni is. You can now have a fully
5:48 functional memory layer that is able to
5:50 refer with in-depth context and
5:52 afterwards you can then delete all the
5:54 context by refreshing it with the delete
5:56 all command. But now let's actually get
5:58 started with the UI cuz I believe it'll
6:00 be a lot easier for you to work with
6:03 Cognney's memory layer through this UI
6:05 and you will be able to now open it up
6:08 within your local host and it's super
6:10 easy to get started. This is the Cogni
6:13 local dashboard and essentially on the
6:15 left hand side is where you can add data
6:18 to Cognney. You can see there is an
6:20 example reference of a Python
6:22 development file with Cogni tutorial
6:24 that has been uploaded and it is
6:26 something that has listed down all the
6:29 different code cells, the markdown cells
6:31 and it gives you a good reference of
6:33 this document. There's also other
6:36 Cognney instances like the local Cognney
6:38 instance that you have it connected
6:40 with. You can add different data sets as
6:43 well to Cognney. You have the main data
6:45 set. You can also have it linked to the
6:48 cloud and this is where you can provide
6:50 your API key from their platform so that
6:53 you can connect it to the cloud. To get
6:55 started, we're going to add new data to
6:57 the data set. This is where we're adding
6:59 large amounts of context about the
7:02 channel and this is entailing a lot of
7:04 information of what the channel is
7:07 about, strategies of videos, thumbnails,
7:09 and etc. So we can go ahead and add the
7:12 selected files and it'll take a couple
7:14 of minutes to process and ingest it
7:16 within the memory system. So it looks
7:18 like my data has been uploaded. Now what
7:21 we can do is upload a new notebook. So
7:23 we can create one from scratch. We can
7:25 give it a name and within the main
7:28 notebook. We can go ahead and query our
7:30 data by simply running this first cell
7:33 of code. This is where it is going to be
7:36 able to use the knowledge graph based
7:38 off the memory layer that we have
7:40 configured and it is going to be able to
7:42 query it by running it. So within a
7:44 couple seconds that you can see that it
7:47 is able to run our knowledge base which
7:50 is the YouTube channel data set and you
7:52 can see that it is providing us the
7:54 context which talks about what our
7:57 YouTube channel is about and it also
7:59 creates the knowledge graph for us. If
8:01 you like this video and would love to
8:03 support the channel, you can consider
8:05 donating to my channel through the super
8:07 thanks option below. Or you can consider
8:10 joining our private Discord where you
8:11 can access multiple subscriptions to
8:14 different AI tools for free on a monthly
8:17 basis, plus daily AI news and exclusive
8:19 content, plus a lot more. This is just
8:21 one simple way for you to access the
8:24 memory layer using the UI. It is
8:27 something that goes further and beyond
8:29 as you can have it so that you can unify
8:31 your data files, code, docs and
8:33 conversations into searchable
8:35 intelligent memory. And not just that,
8:38 you can incorporate it within chat bots.
8:40 You can use it within coding assistance,
8:42 documentation intelligence, human
8:45 resources and so many other types of
8:48 methods. It is going to let you query in
8:50 natural language. You can uncover
8:52 patterns. You can align your work with
8:54 the best practices or expert
8:57 contributions. You can even ingest data,
8:59 build a knowledge graph, you can even
9:01 infer rules and you can have a
9:04 continuous improved result through
9:06 feedback. And for practical use cases,
9:08 like we had mentioned, you have so many
9:10 other methods where you can even ingest
9:14 it within an AI agent. So it has inbuilt
9:17 memory and it's able to query knowledge
9:20 bases research and it can even make your
9:22 project so much smarter, more consistent
9:25 and more context aware. Now I'll leave
9:26 all these links in the description below
9:28 so that you can easily get started. This
9:30 is a remarkable open-source tool.
9:32 There's a lot of resources that they
9:33 have that will showcase how you can
9:36 easily get started. But this is the
9:38 capability of Cognney. It is something
9:40 that will easily and greatly elevate
9:43 your project. But that's basically it,
9:44 guys. Thank you guys so much for
9:45 watching. Make sure you go ahead and
9:47 subscribe to the second channel, join
9:48 the newsletter, join our private
9:50 Discord, follow me on Twitter, and
9:51 lastly, make sure you guys subscribe,
9:52 turn on notification bell, like this
9:54 video, and please take a look at our
9:55 previous videos because there's a lot of
9:57 content that you'll truly benefit from.
9:58 With that thought, guys, have an amazing
10:00 day. Drop positivity, and I'll see you
