Projects/Nepomuk

About Nepomuk

This page is dedicated to Nepomuk development ideas, progress, experiments, and is a general starting point for new developers.

For general information about the Nepomuk project see the dedicated Nepomuk homepage.

Developer Coordination

The Nepomuk project is maintained by Sebastian Trueg of Mandriva.

Documentation

The following links provide good reads for getting used to the Nepomuk system and its APIs.

• Development Tutorials
• Nepomuk Tips and Tricks
• Nepomuk API Documentation
• Soprano (RDF storage) API
• Using the Nepomuk Resource Code generator and the Soprano Ontology class generator in cmake

As Nepomuk is highly dependent on its data in the RDF store and the used ontologies, one might consider to read up on RDF and the Nepomuk ontogies:

• RDF Primer
• Nepomuk Ontologies
• Experimental Nepomuk Ontologies and Ideas for new ones

Events

June 19-21, 2009 - Coding Sprint 2009 Freiburg, Germany

ToDo

Nepomuk is a rather young project with a notorious shortage in developers. There are many tasks and subprojects to get ones hands dirty on. Unlike other projects like Plasma, however, developing for Nepomuk is not easy. One has to read up on a lot of things and fight some day-to-day annoyances. But: helping with the development will improve the situation in any case.

If you are interested in working on a task in this list, please contact Sebastian Trueg.

Low level Nepomuk Development Tasks

The low-level development tasks are those that are not directly reflected in the GUI or even in the API used by most developers. However, they are important in terms of performance, scalability, and compatibility.

Soprano Transaction Support

Soprano is the RDF database framework used in Nepomuk. Currently Soprano does not support transactions, i.e. sets of commands that can be rolled back. An experimental development branch exists which already contains new API for transaction support (while keeping BC).

It still misses an implementation of the transaction support in Soprano backends (Sesame2 and Virtuoso) and in the client/server architecture.

Multi-threaded Storage service

At the moment the Nepomuk storage service is single-threaded. This slows down the system when more than one application tries to access data. Making the Soprano server implementation (which the Nepomuk service is based on) multi-threaded should not be that hard, knowing that the storage backend (sesame2) is already thread-safe.

General Nepomuk

Catching all file moves

Work already begun by Sebastian Trueg - help always welcome

Nepomuk uses an RDF database for all data. This includes file metadata. Files are referenced by URL. The problem with this is that when a file is moved or renamed we have to realize this and update the metadata accordingly (update the URL in the database).

For KIO this is fairly simple since we have KDirNotify. The Nepomuk filewatch service takes care of this and updates the metadata whenever KIO moves or deletes a file.

However, if a file is moved by a non-KDE application (typical example: the shell via the mv command) the filewatch service does not notice it and the file -> metadata link is gone. This is a bad situation which sadly cannot be solved easily. Systems like inotify are too restricted.

Thus, while having a more powerful replacement for inotify would be great, in the meantime we should work with what we got.

The idea is to create a Nepomuk service that tries very hard to find file moves. It would regularly check the database for dangling metadata and then try to find the file using all kinds of evidence:

• file name matching
• xattrs if available (this would mean that Nepomuk::Resource also needs to set the xattrs at some point)
• checksums, maybe the checksum of the first N bytes or something like that to speed the process up
• compare metadata extracted by strigi
• etc.

All this information should be used to generate a score which indicates the certainty of the file matching. Then the final decision would have to be made by the user.

Hints:

• Try to detect if a complete folder has been moved (or deleted) and do not ask the user for every single file.

Handling of external storage

Work already begun by Daniel Winter at the Nepomuk workshop.

A typical problem with the way Nepomuk handles files and file metadata are removable storage devices. They can be mounted at different paths on different systems. But still one wants to keep the metadata stored in Nepomuk. If possible one would even want to be able to search for files saved on an USB stick even if it is not plugged in.

The blog entry about removable storage in Nepomuk already discusses this problem and shows some existing code in KDE's playground which tries to tackle this problem.

However, one actually needs more. The system would have to be embedded into KIO to make sure the metadata cache on the removable storage device is always up-to-date. Also it is directly related to the problem of relative vs. absolute file URLs.

Relative vs. Absolute File URLs

Currently Nepomuk uses the absolute file URLs as URI identifiers for the resources representing the files in the Nepomuk RDF store. The file ~/test.png for example has the resource URI file:///home/<username>/test.png. This is nice in many situations since one can simply use the file URL to query file metadata but on the other hand we need to change a lot of triples whenever the file is moved (not to mention the removable storage problem above).

Thus, the idea is to use random URI identifiers for new file resources and store the file path relative to the mount point. This would solve the above problem with removable devices and make updates after file moves simpler (only update the path).

This problem should probably be tackled by introducing a class Nepomuk::File as a subclass to Nepomuk::Resource which handles all these special file stuff like making sure we have a correct nao:filePath property and so on (currently all that is done with an if clause in Nepomuk::Resource.

Nepomuk Backup Service

We need a backup solution. The idea is the typical one: have a Nepomuk service that allows to specify update intervals and manual updates.

The service should ignore all data extracted by Strigi, i.e. data that can be recreated deterministically. This can easy be determined by checking the context/named graph the data statements are stored in. Strigi stores all extracted data in one context which is marked as the http://www.strigi.org/fields#indexGraphFor for the file in question. Thus, a query along the lines of the following would work:

select ?s ?p ?o ?g where {
     graph ?g { ?s ?p ?o . } . 
     OPTIONAL { ?g strigi:indexGraphFor ?x . } . 
     FILTER(!BOUND(?x)) .
}

Other features could include replacement of the home directory like it is done in KConfig. This way the data could be re-imported in another user account.

Nepomuk Toolbox

Provide a GUI that allows to call methods such as optimize and rebuildIndex on the storage service. The latter method is not commited yet due to the KDE 4.3 feature freeze but will be afterwards.

It would also be useful to have Nepomuk register such operations (including the data conversion when changing backends) via the notification system.

GUI

Better tagging widget

Currently there is a tagging widget in kdelibs which is pretty ugly and not even used. Then there is the tag cloud used in Dolphin. The latter was already criticized for not being appropriate in that situation.

Thus, it would be great to make Nepomuk::TagWidget a nice and usable (maybe talk to the usability people) widget that can then be used in Dolphin, Gwenview, and pretty much any application that wants to tag resources.

Ideas

There are many ideas on how to improve the Nepomuk system or on how to use it. This is the place to list them all.

Feel free to add your own ideas. Please leave your name in case someone wants to contact you for details or a discussion of the idea.

Remember download locations

As blogged before remembering the download location and the referrer web page is a pretty good idea. The most pressing problem at the moment is finishing the download ontology.

Giving the user the option to tag either at the download dialogue and/or the kuiserver download notification would make it easier to tag instantly rather than waiting for the file to download and then rmembering to come back when it's finished and tag then. When bookmarking in Firefox, FF adds some suggested tags (fairly accurately too!) which the user can delet / add to. I suggest the same for downloaded files. This way, the web pages meta tags / title can be used for suggestions if the user doesn't feel like tagging , doesn't know about it, or just to speed the process up.

Use Nepomuk in the KDE Menu

One could think of using nepomuk search in the KMenu to look for applications or even files or persons.

Remember Usage of movie/sound files

Media players such as Dragonplayer or Amarok could remember when movie/sound files have been watched/listened to. The last time is interesting but maybe also a history.

In any case, it allows to quickly access unwatched episodes.

Tool to gather annotation statistics about selected files

Quoting blog comment as an example: "I am using Nepomuk to tag/rate schoolwork from my students. For every paper/file I tag it with seen/unseen and rate it with the actual grade I want to give (0-5). When I have seen them all, I collect the results into a spreadsheet. It would make my life (even) easier if, by selecting a bunch of file I could have a summary (one I could save in some text form) of all ratings/tags for each file in the selection."

One could think of an action in Dolphin (for a first prototype this is always a good idea) which triggers a collection of all metadata which is then layed out according to the user's wishes: html, plain text, odt, whatever.

Add support for qualified links/relations

This is a somewhat low-level idea with no visible results as long as applications don't use it, but I think that having it implemented would allow for some nice possibilities.

Basically, the goal is to have some generic way of attaching a "quality" to any “thing -- property” assignment, in order to cope with the varying credibility/certainty of different meta-data collection methods such as user input, heuristic algorithms, circumstantial guesses, etc. in a transparent and unified way.

This would among other things allow implementing many automatic-data-collection ideas like NLP-support in a more user-friendly (that is: non-intrusive) fashion.

For more details & discussion see Projects/Nepomuk/Qualified Relations Idea.

Folder Cloud in Dolphin/KDirOperator

Using information from the Nepomuk DB about usage frequency of folders (or the files within) it would be nice to have the folders be presented in a cloud. More often used or more important folders would appear bigger.

This is a nice idea originally posted on kde-look.org.

Standalone Search Application

Create a standalone search application using Nepomuk. Currently, the KDE desktop does not have a clear application that will search the user's entire hard drive for a file. One application that implements this well is Beagle in Gnome.

This standalone application would provide the full search. This application could also be the place for implementing the tagging idea above.

In playground we already have a simple search client. It could be the basis for this tool. The existing client does show the results in categories. This could be further improved. It also uses a first attempts at creating a generic resource presentation framework, i.e. a way to handle drawing of arbitrary resource types through plugins and even a rule system.

Nepomuk based backup system

Nepomuk has a huge potential for an intelligent backup system. The point here is that Nepomuk could "know" that a certain file on a certain device is the backup of a local file. Then, when the device is available it would trigger an automatic update of the backup.

The user could, for example, just tag a folder with "Backup" (better use a dedicated ontology) and the system would ask where to back it up and perform all the necessary tasks. Backup history and recovery could then be done inside the Nepomuk resource. The key point here is really the fact that the system would "know" what a backup is, recognize one when it sees it and know what to do with it.

Nepomuk based versioning system

This is partly related to the backup system. User should be able to tag a version of a file, a bit like in svn. When opening a file, there could be a list of saved versions, in case user wants to revert changes or something like that.

This could even be combined with automatic detection. For example in email: somebody sends you the second version of a paper which is then saved. It would be great to remember that the new file is the second version of the first one. Then the system could warn if one opens the older version.

File Boxes

There is a nice idea about file boxes which allow to temporarily group files to perform some actions on them here: http://bugs.kde.org/show_bug.cgi?id=200461

This could be done using Nepomuk. I am not sure, however, if Nepomuk is really the correct choice here. Maybe a simple kded service and a KIO slave nicely integrated into Dolphin and the file dialog would be sufficient.

Categorize new files

Let Strigi emit a D-Bus signal on new files (only after the initial indexing so we do not get signals for all files) that appear in typical document folders (so we do not get signals on temp and log files and the like).

When a new file appears propose to relate it to the current Nepomuk context (the context service is in playground: a very simple one only maintaining one URI which is the current context and can be any resource. Typically, however, it would be a project or task or event).

Also use the information extracted by Strigi (mostly nie:plainTextContent and nie:description and nie:name) to generate annotation suggestions through Scribo and propose them to the user, too. This could be done via notifications (in a first version) and later in a nicer plasma GUI.

Here rating of the suggestions is important. Nepomuk::Annotation already provides a relevance() method but most plugins' relevance generation code is rather simple and could use improvement.

FIXME: add your own ideas

Linking between documents

I usually deal with lots of scientific papers in the form of searchable pdf's. My idea is twofold: 1) Have a 'Google scholar' type search that allows me to see the relations between papers and retrace an idea to its original author. 2) Each paper refers to a few other that I might have already on disk. My idea is to have okular integration such that when I click on a reference it opens the respective file based on author, date, journal, etc.